TrimState.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/Io.hh>
#include <diades/automata/experimental/Trimming.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-trimstates");
const string briefcomment(": this program removes some states from the given ddaut automaton and\n  write as output the new automaton  (output file or standard output).\n\n");
const string detailedcomment=R"(dd-trimstates removes some states from the given ddaut automaton and
writes as output the new automaton  (output file or standard output). The states to 
remove can be characterised by a regular expression regexp so that if the label
of the state matches the regular expression, it is simply removed (and all the transitions
involved with this state).

Here is a first example:

 dd-trimstates file.ddaut -r '.*o\.p=ko.*'
  
In this example, we ask to remove the states in file.ddaut labeled with string such
that it contains the substring 'o.p=ko'. dd-trimstates can also be used to remove 
deadlocks in file.ddaut, as follows:

 dd-trimstates file.ddaut --no-deadlock

It is also possible to remove deadlocks by automatically disabling some controllable events
(see Ramadge and Wonham theory). In the following example, dd-trimstates will simply disable
some controllable events from some states to ensure that the result has no deadlocks. A file
with a 'cont' suffix is a file that contains a list of events, one per line.

dd-trimstates file.ddaut --no-deadlock -c controllable.cont

It is also possible to combine both type of operations like:

dd-trimstates file.ddaut --no-deadlock -c controllable.cont -r '.*o\.p=ko.*'

In this case, the program will first remove the states '.*o\.p=ko.*' and then remove
deadlocks by disabling controllable events.
)";


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

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 (.ddaut format)")
    ("regexp,r", Poptions::value< string >(), "regular expression on the name of the states inside a set of quotes: 'regexp' for details see\n http://www.cplusplus.com/reference/regex/ECMAScript/")
    ("output,o", Poptions::value< string >(), "outfile name (.ddaut format)")
    ("controllable,c",  Poptions::value< string >(), "controllable event name (.cont format, single list of events, one per line)")
    ("no-deadlock", "removing deadlocks")
    ("verbose", "verbose mode")
    ;
  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::DdAutFsm;
using Diades::Automata::Experimental::DdAutEventManager;
using Diades::Automata::Experimental::DdAutStateManager;
using Event = DdAutFsm::EventPropertyId;

size_t readControllableEvents(const string & contName,
                              std::set<std::string> & controllable)
{
  if(!contName.empty())
    {
      ifstream file(contName.c_str());
      if(file.is_open())
       {
         std::istream_iterator<std::string> it(file);
      std::istream_iterator<std::string> end;
      while(it!=end)
        {
          controllable.insert(*it);
          ++it;
        }
      file.close();
    }
  else
   {
     return printCommandLineError(Msg("Error when opening the 'cont' automaton file %1%") % contName);
   }
    }
  return SUCCESS;
}

size_t
trimDdAutStates2(const string & fileName, const string & output, const string & regexp,const string & contName, bool noDeadLock, bool verbose)
  {
    DdAutFsm fsm;
    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);
      }
    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);
    }
  if(verbose)
    {
      std::cout << "Verbose mode is on.\n";
    }
  if(!regexp.empty())
    {
      if(verbose)
        {
          std::cout << "Trimming states whose label matches the following regular expression: " << regexp << "\n";
        }
      std::regex reg(regexp);
      for(const auto & stateProperty: sManager.storage())
        {
          if(std::regex_match(stateProperty,reg))
            {
              if(verbose)
                {
                  std::cout << "Deleting state: " << stateProperty << "\n";
                }
              fa.deleteState(fa.getState(sManager.statePropertyId(stateProperty)));
            }
        }
    }
  if(verbose && regexp.empty())
    {
      std::cout << "No regular expression found.\n";
    }
  
  if(noDeadLock)
    {
      if(verbose)
        {
          std::cout << "Need to trim deadlock states.\n";
        }
      ControlPattern pattern(fa);
      std::set<std::string> controllable;
      readControllableEvents(contName,controllable);
      if(verbose)
        {
          std::cout << "Controllable events:\n";
        }
      std::for_each(fa.eventBegin(),fa.eventEnd(),
                    [&](const Event & e)
                    {
                      bool found = false;
                      if(controllable.empty())
                        {
                          pattern.disable(e);
                        }
                      else
                        {
                          auto it = controllable.begin();
                          while(!found && it!=controllable.end())
                            {
                              found= eManager.getEvent(e).find(*it)!=std::string::npos; 
                              if(!found) { ++it; }
                            }
                          if(found)
                            {
                              if(verbose)
                                {
                                  std::cout << eManager.getEvent(e) << " (-> " << *it << ")\n";
                                }
                              pattern.disable(e);
                            }
                        }
                    });
      std::list<DdAutFsm::StatePropertyId> stateIds;
      std::list<std::pair<DdAutFsm::StatePropertyId, DdAutFsm::EventPropertyId>> disabled;
if(!controlledTrimmingDeadlockState(fa, pattern,fa.stateBegin(),fa.stateEnd(),std::inserter(stateIds,stateIds.begin()),
                                              std::inserter(disabled,disabled.begin())))
        {
          return printCommandLineError("The result is empty, check that it is really what you want to do.");
        }
      if(verbose)
        {
          for(const auto & d : disabled)
            {
              std::cout << "Disabling "
                        << eManager.getEvent(d.second)
                        << " from state "
                        << sManager.getStateProperty(d.first)
                        << "\n";
            }
          for(const auto & id: stateIds)
            {
              std::cout << "Deleting state: " << sManager.getStateProperty(id) << "\n";
            }
        }
    }
  if(output.empty())
    {
      if(verbose)
        {
          std::cout << "Writing resulting finite-state machine herebelow:\n";
        }
      faToDdAutFile(std::cout, {fa, sManager, eManager});
    }
  else
    {
      if(verbose)
        {
          std::cout << "Writing resulting finite-state machine in " << output << "\n";
        }
      ofstream outfile(output.c_str());
      if(outfile.is_open())
        {
          faToDdAutFile(outfile, {fa, sManager, eManager});
          outfile.close();
          if(verbose)
            {
              std::cout << "done.\n";
            }
          return SUCCESS;
        }
      else
        {
          return printCommandLineError(Msg("Error when creating the dot file %1%") % output);
        }
     }
   return ERROR_UNHANDLED_EXCEPTION;
}


size_t
trimDdAutStates(const string & fileName, const string & output, const string & regexp, const string & contName, bool noDeadLock, bool verbose)
{
  if(!output.empty())
    {
      if(!suffixes.match(output, "ddaut"))
        {
          return printCommandLineError(Msg("Expecting an output file with a name ending with .ddaut, but I read %1%") % output);
        }
    }
  if(!contName.empty())
    {
      if(!suffixes.match(contName, "cont"))
        {
          return printCommandLineError(Msg("Expecting a file containing a list of controllable events  with a name ending with .cont, but I read %1%") % contName);
        }
      
    }
  
  if(suffixes.match(fileName, "ddaut"))
       {
         return trimDdAutStates2(fileName, output,regexp,contName,noDeadLock,verbose);
       }
  else
    {
      return printCommandLineError(Msg("Expecting a file with a name ending with .ddaut, but I read %1%") % fileName);
    }
  return ERROR_UNHANDLED_EXCEPTION;
}


  int
    main(int argc, char** argv)
  {
    std::string fileName, output, contName;
    std::string regexp;
    bool deadlock = false;
    bool verbose = false;
    try
      {
     
        Poptions::options_description desc("Options");
        Poptions::variables_map vm;
        initialiseOptions(argc, argv, desc, vm);
        if(vm.count("help"))
          {
            return printUsage(program + briefcomment + detailedcomment, desc);
          }
        if(vm.count("file"))
          {
            fileName = vm["file"].as<std::string> ();
          }
        if(vm.count("output"))
          {
            output = vm["output"].as<std::string>();
          }
        if(vm.count("regexp"))
          {
            regexp = vm["regexp"].as<std::string>();
          }
        if(vm.count("no-deadlock"))
          {
            deadlock = true;
          }
        if(vm.count("verbose"))
          {
            verbose = true;
          }
        if(vm.count("controllable"))
          {
            contName = vm["controllable"].as<std::string> ();
          }
      }
    catch(Poptions::required_option & e)
      {
        return printCommandLineError(e.what());
      }
    catch(Poptions::error & e)
      {
        return printCommandLineError(e.what());
      }
   

    return trimDdAutStates(fileName, output,regexp, contName, deadlock, verbose);
  }