Project.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/Project.hh>
#include"../AutomataInterface.hh"
#include "diades/automata/experimental/DdAutFileDescriptor.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-project");

/*
 * 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)")
                        ("event,e", Poptions::value<std::vector< string > >(), "a list of events to project")
                        ("noevent,n", Poptions::value<std::vector< string > >(), "a list of events not to project")
                        ;
        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;
using Diades::Automata::Experimental::AutEventId;

template<typename FsmType,
typename Event>
bool
getProjectedEvents(const FsmType & fsm,
                                   std::vector<Event> & events,
                                   std::vector<Event> & noevents,
                                   std::vector<Event> & projectedEvents)
{
        if(events.empty())
        {
                if(noevents.empty())
                {
                        return false;
                }
                else
                {
                        std::sort(noevents.begin(), noevents.end());

                        // take any event from fsm that is not in noevent
                        auto fsmEvents = fsm.events();
                        std::sort(fsmEvents.begin(), fsmEvents.end());
                        std::set_difference(fsmEvents.begin(), fsmEvents.end(), noevents.begin(), noevents.end(),
                                                                std::inserter(projectedEvents, projectedEvents.begin()));
                }
        }
        else
        {
                auto fsmEvents = fsm.events();
                std::sort(events.begin(), events.end());
                std::sort(fsmEvents.begin(), fsmEvents.end());
                std::set_intersection(fsmEvents.begin(), fsmEvents.end(), events.begin(), events.end(),
                                                        std::inserter(projectedEvents, projectedEvents.begin()));
                // check that projectedEvents does not contain any event from noevent
                std::vector<Event> intersection;
                std::sort(noevents.begin(), noevents.end());
                std::set_intersection(projectedEvents.begin(), projectedEvents.end(),
                                                        noevents.begin(),
                                                        noevents.end(),
                                                        std::inserter(intersection, intersection.begin()));
                if(!intersection.empty())
                {
                        return false;
                }
        }
        return true;
}

size_t
projectAut(const std::string & fileName, const std::string & output,
                   std::vector<std::string> & events,
                   std::vector<std::string> & noevents)
{

        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);
        }

        AutFsm projection;
        std::vector<AutEventId> projectedEvents;
        if(getProjectedEvents(fsm, events, noevents, projectedEvents))
        {
                project(fsm, projection,
                                projectedEvents.begin(), projectedEvents.end());
        }
        else
        {
                return printCommandLineError(Msg("Error when analysing the events/noevents to project, they are incompatible please check them \n are they BOTH empty? \n Is an event part of both sets? \n events are %1%,\n noevents are %2%")
                                                                        % toStream(events.begin(), events.end()) % toStream(noevents.begin(), noevents.end()));
        }
        return writeAut(projection, output, suffixes);
}

bool
getProjectedEvents(const DdAutFsm & fsm,
                                   const std::vector<std::string> & events,
                                   const std::vector<std::string> & noevents,
                                   DdAutEventManager & eManager,
                                   std::vector<DdAutEventId> & projectedEvents)
{
        std::vector<DdAutEventId> eventIds;
        std::vector<DdAutEventId> noeventIds;
        std::for_each(events.begin(), events.end(),
                                [&](const std::string & event)
                                {
                                        if(eManager.hasEvent(event))
                                        {
                                                eventIds.push_back(eManager.eventId(event));
                                        }
                                });
        std::for_each(noevents.begin(), noevents.end(),
                                [&](const std::string & event)
                                {
                                        if(eManager.hasEvent(event))
                                        {
                                                noeventIds.push_back(eManager.eventId(event));
                                        }
                                });
        return getProjectedEvents(fsm, eventIds, noeventIds, projectedEvents);
}

size_t
projectDdaut(const std::string & fileName, const std::string & output,
                         std::vector<std::string> & events,
                         std::vector<std::string> & noevents)
{
        DdAutFileDescriptor descriptor;
        DdAutEventManager eManager;
        DdAutStateManager sManager;
        DdAutStateManager sManagerProj;
        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())
        {
                DdAutFA fa;

                auto loaded = faFromDescriptor(descriptor, fa, sManager, eManager);
                if(!loaded)
                {
                        return printCommandLineError(Msg("Error when loading the 'ddaut descriptor of the finite automaton file %1%") % fileName);
                }


                std::vector<DdAutEventId> projectedEvents;
                DdAutFA projectedFA;
                DdAutProjection projectionLabels;

                if(getProjectedEvents(fa, events, noevents, eManager, projectedEvents))
                {
                        project(fa, projectedFA, sManager, sManagerProj, projectionLabels, projectedEvents.begin(), projectedEvents.end());
                }
                else
                {
                        return printCommandLineError(Msg("Error when analysing the events/noevents to project, they are incompatible please check them \n are they BOTH empty? \n Is an event part of both sets? \n events are %1%,\n noevents are %2%")
                                                                                 % toStream(events.begin(), events.end()) % toStream(noevents.begin(), noevents.end()));
                }
                return writeFiniteAutomaton(ConstManagedDdAutFA(projectedFA, sManagerProj, eManager), output, suffixes);
        }
        else
        {
                DdAutFsm fsm;
                auto loaded = fsmFromDescriptor(descriptor, fsm, sManager, eManager);
                if(!loaded)
                {
                        return printCommandLineError(Msg("Error when loading the 'ddaut descriptor of the finite state machine file %1%") % fileName);
                }
                
                std::vector<DdAutEventId> projectedEvents;
                DdAutFsm projectedFsm;
                DdAutProjection projectionLabels;

                if(getProjectedEvents(fsm, events, noevents, eManager, projectedEvents))
                {
                        project(fsm, projectedFsm, sManager, sManagerProj, projectionLabels, projectedEvents.begin(), projectedEvents.end());
                }
                else
                {
                        return printCommandLineError(Msg("Error when analysing the events/noevents to project, they are incompatible please check them \n are they BOTH empty? \n Is an event part of both sets? \n events are %1%,\n noevents are %2%")
                                                                                 % toStream(events.begin(), events.end()) % toStream(noevents.begin(), noevents.end()));
                }
                return writeFiniteStateMachine(ConstManagedDdAutFsm(projectedFsm, sManagerProj, eManager), output, suffixes);
        }
        return false;
}

size_t
projectFsm(const std::string & fileName, const std::string & output,
                   std::vector<std::string> & events,
                   std::vector<std::string> & noevents)
{
        if(fileName.empty())
        {
                return printCommandLineError(Msg("Expecting a filename but I did not get anything. Use dd-project --help for documentation."));
        }
        if(suffixes.match(fileName, "aut"))
        {
                return projectAut(fileName, output, events, noevents);
        }
        else
        {
                if(suffixes.match(fileName, "ddaut"))
                {
                        return projectDdaut(fileName, output, events, noevents);
                }
                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;
        std::vector<std::string> events;
        std::vector<std::string> noevents;
        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>();
                }
                if(vm.count("event"))
                {
                        events = vm["event"].as<std::vector < std::string >> ();
                }
                if(vm.count("noevent"))
                {
                        noevents = vm["noevent"].as<std::vector < std::string >> ();
                }
        }
        catch(Poptions::required_option & e)
        {
                return printCommandLineError(e.what());
        }
        catch(Poptions::error & e)
        {
                return printCommandLineError(e.what());
        }
        return projectFsm(fileName, output, events, noevents);
}