DiaDes  0.1
DIAgnosis of Discrete-Event System
Determine.cc
Go to the documentation of this file.
1 
10 #include <cstdlib>
11 #include<iostream>
12 #include<fstream>
13 #include<regex>
14 #include<boost/program_options.hpp>
15 
23 #include"../AutomataInterface.hh"
24 
25 using namespace std;
26 using namespace Diades::Automata::Experimental;
27 using namespace Diades::Utils;
28 using namespace Diades::CmdInterface;
29 
30 namespace Poptions = boost::program_options;
31 
32 
33 
38 const string program("dd-determine");
39 
40 /*
41  * File suffixes
42  */
43 FileSuffixes suffixes({"aut","ddaut"});
44 
45 
53 void initialiseOptions(int argc, char * argv[],
54  Poptions::options_description & desc,
55  Poptions::variables_map & vm) {
56  desc.add_options()
57  ("help,h", "produce help message")
58  ("file,f", Poptions::value< string >(), "automaton file (.aut/.ddaut format)")
59  ("output,o", Poptions::value< string >(), "outfile name (.aut/.ddaut format)");
60  Poptions::positional_options_description p;
61  p.add("file", 1);
62  Poptions::store(Poptions::command_line_parser(argc, argv).options(desc).positional(p).run(), vm);
63  Poptions::notify(vm);
64 }
65 
66 
72 
73 
74 
75 
76 
84 size_t determineAut(const std::string & fileName, const std::string & output)
85 {
86 
87  AutFsm fsm;
88  ifstream file(fileName.c_str());
89  if(file.is_open())
90  {
91  auto loaded = fromAutFile(file, fsm);
92  file.close();
93  if(!loaded)
94  {
95  return printCommandLineError(Msg("Error when loading the automaton file %1%")%fileName);
96  }
97  }
98  else
99  {
100  return printCommandLineError(Msg("Error when opening the automaton file %1%")%fileName);
101  }
102  AutFsm deterministicFsm;
103  AutStateCreator creator(fsm,deterministicFsm);
104 
105  determine(fsm,deterministicFsm,creator);
106  return writeAut(deterministicFsm,output,suffixes);
107 }
108 
116 size_t determineDdaut(const std::string & fileName, const std::string & output)
117 {
118  DdAutFileDescriptor descriptor;
119  DdAutEventManager eManager;
120  DdAutStateManager sManager;
121  DdAutStateManager sManagerDet;
122  ifstream file(fileName.c_str());
123  if(file.is_open())
124  {
125  auto loaded = descriptor.readStream(file);
126  file.close();
127  if(!loaded)
128  {
129  return printCommandLineError(Msg("Error when loading the 'ddaut' automaton file %1%")%fileName);
130  }
131  }
132  else
133  {
134  return printCommandLineError(Msg("Error when opening the 'ddaut' automaton file %1%")%fileName);
135  }
136  if (descriptor.acceptorBegin()!=descriptor.acceptorEnd())
137  {
138  // it is a finite automaton
139  DdAutFA fa;
140  bool result = faFromDescriptor(descriptor,fa, sManager, eManager);
141  if(!result)
142  {
143  return printCommandLineError(Msg("Error when converting the DdAutFileDescriptor from %1% to a Finite Automaton")%fileName);
144  }
145  DdAutFA deterministicFA;
146  ManagedBeliefStateBasedStateCreator<DdAutFA,DdAutDisjunction> creator(fa,deterministicFA,sManager,sManagerDet);
147  determine(fa,
148  deterministicFA,
149  creator);
150  return writeFiniteAutomaton({deterministicFA,sManagerDet,eManager},output,suffixes);
151  }
152  else
153  {
154  // it is a finite state machine
155  DdAutFsm fsm;
156  bool result = fsmFromDescriptor(descriptor,fsm, sManager, eManager);
157  if(!result)
158  {
159  return printCommandLineError(Msg("Error when converting the DdAutFileDescriptor from %1% to a Finite State Machine")%fileName);
160  }
161  DdAutFsm deterministicFsm;
162  ManagedBeliefStateBasedStateCreator<DdAutFsm,DdAutDisjunction> creator(fsm,deterministicFsm,sManager,sManagerDet);
163  determine(fsm,
164  deterministicFsm,
165  creator);
166  return writeFiniteStateMachine({deterministicFsm,sManagerDet,eManager},output,suffixes);
167  }
168  return false;
169 }
170 
171 
179 size_t determineFsm(const std::string & fileName, const std::string & output)
180 {
181 
182  if (suffixes.match(fileName, "aut")) {
183  return determineAut(fileName,output);
184  }
185  else
186  {
187  if(suffixes.match(fileName, "ddaut"))
188  {
189  return determineDdaut(fileName,output);
190  }
191  else
192  {
193  return printCommandLineError(Msg("Expecting a file with a name ending with .aut, but I read %1%") % fileName);
194  }
195  }
197 }
198 
199 
200 
201 
202 
209 int main(int argc, char** argv)
210 {
211  std::string fileName, output;
212  try
213  {
214  Poptions::options_description desc("Options");
215  Poptions::variables_map vm;
216  initialiseOptions(argc, argv, desc, vm);
217  if(vm.count("help"))
218  {
219  return printUsage(program,desc);
220  }
221  if(vm.count("file"))
222  {
223  fileName = vm["file"].as<std::string>();
224  }
225  if(vm.count("output"))
226  {
227  output = vm["output"].as<std::string>();
228  }
229  }
230  catch(Poptions::required_option & e)
231  {
232  return printCommandLineError(e.what());
233  }
234  catch(Poptions::error & e)
235  {
236  return printCommandLineError(e.what());
237  }
238  return determineFsm(fileName,output);
239 }
240 
size_t determineAut(const std::string &fileName, const std::string &output)
Definition: Determine.cc:84
size_t writeAut(const Diades::Automata::Experimental::AutFsm &fsm, const std::string &output, const FileSuffixes &suffixes)
StateMachine< AutStateId, AutEventId > AutFsm
Definition: AutFile.hh:45
int main(int argc, char **argv)
Definition: Determine.cc:209
StatePropertyManager< DdAutStateLabel, DdAutStateId > DdAutStateManager
Definition: DdAutFile.hh:63
size_t writeFiniteAutomaton(const Diades::Automata::Experimental::ConstManagedDdAutFA &mfa, const std::string &output, const FileSuffixes &suffixes)
bool fsmFromDescriptor(const DdAutFileDescriptor &descriptor, DdAutFsm &fsm, DdAutStateManager &sManager, DdAutEventManager &eManager)
const size_t ERROR_UNHANDLED_EXCEPTION
Definition: CmdInterface.hh:35
size_t printCommandLineError(const string &msg)
Definition: CmdInterface.cc:98
bool faFromDescriptor(const DdAutFileDescriptor &descriptor, DdAutFA &fa, DdAutStateManager &sManager, DdAutEventManager &eManager)
STL namespace.
size_t determineDdaut(const std::string &fileName, const std::string &output)
Definition: Determine.cc:116
vector< string > options(numberOfOptions)
void determine(const Fsm &machine, Fsm &deterministicMachine, StateCreator &creator)
Definition: Determine.hh:65
bool match(const std::string &fileName, const std::string &suffix) const
Definition: CmdInterface.cc:54
FileSuffixes suffixes({"aut","ddaut"})
size_t writeFiniteStateMachine(const Diades::Automata::Experimental::ConstManagedDdAutFsm &mfsm, const std::string &output, const FileSuffixes &suffixes)
EventManager< DdAutEventLabel, DdAutEventId > DdAutEventManager
Definition: DdAutFile.hh:68
bool fromAutFile(std::istream &stream, AutFsm &fsm)
StateMachine< DdAutStateId, DdAutEventId > DdAutFsm
Definition: DdAutFile.hh:42
void initialiseOptions(int argc, char *argv[], Poptions::options_description &desc, Poptions::variables_map &vm)
Definition: Determine.cc:53
boost::format Msg
Definition: Verbose.hh:42
size_t determineFsm(const std::string &fileName, const std::string &output)
Definition: Determine.cc:179
const string program("dd-determine")
virtual bool readStream(std::istream &stream)
void printUsage(const po::options_description &desc)