AutomataInterface.cc

Go to the documentation of this file.

#include<fstream>
#include<diades/utils/Verbose.hh>
#include<diades/automata/experimental/DdAutFileDescriptor.hh>
#include "AutomataInterface.hh"



namespace Diades
{
  namespace CmdInterface
  {
    using Msg = Diades::Utils::Msg;



     
    size_t loadFiniteStateMachine(const std::string & input, const Diades::Automata::Experimental::ManagedDdAutFsm & mfsm)
    {
      Diades::Automata::Experimental::DdAutFileDescriptor descriptor;
      ifstream file(input.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%") % input);
            }
        }
      else
        {
          return printCommandLineError(Msg("Error when opening the 'ddaut' automaton file %1%") % input);
        }
      auto result = fsmFromDescriptor(descriptor, mfsm.fsm, mfsm.sMgr, mfsm.eMgr);
      if(!result)
        {
          return printCommandLineError(Msg("Error when converting the DdAutFileDescriptor from %1% to a Finite Automaton") % input);
        }
      return SUCCESS;
    }
 
    size_t loadFiniteStateAutomaton(const std::string & input,
                                    const Diades::Automata::Experimental::ManagedDdAutFA & mfa)
    {
      Diades::Automata::Experimental::DdAutFileDescriptor descriptor;
      ifstream file(input.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%") % input);
            }
        }
      else
        {
          return printCommandLineError(Msg("Error when opening the 'ddaut' automaton file %1%") % input);
        }
      auto result = faFromDescriptor(descriptor, mfa.fa, mfa.sMgr, mfa.eMgr);
      if(!result)
        {
          return printCommandLineError(Msg("Error when converting the DdAutFileDescriptor from %1% to a Finite Automaton") % input);
        }
      return SUCCESS;
    }

   

    
    size_t
        writeAut(const Diades::Automata::Experimental::AutFsm & fsm, const std::string & output,
                 const FileSuffixes & suffixes)
      {
        std::ofstream out;
        if(!output.empty())
          {

            if(suffixes.match(output, "aut"))
              {
                out.open(output);
                if(!out.is_open())
                  {
                    return printCommandLineError(Msg("Cannot open and write in the 'aut' file %1%") % output);
                  }
                else
                  {
                    if(!toAutFile(out, fsm, true))
                      {
                        return printCommandLineError(Msg("Error when dumping the deterministic automaton in the 'aut' file %1%") % output);
                      }
                out.close();
                }
            }
          else
            {

              if(suffixes.match(output, "ddaut"))
                {
                  out.open(output);
                  if(!out.is_open())
                    {
                      return printCommandLineError(Msg("Cannot open and write in the 'ddaut' file %1%") % output);
                    }
                  else
                    {
                      if(!toAutFile(out, fsm, true))
                        {
                          return printCommandLineError(Msg("Error when dumping the deterministic automaton in the 'ddaut' file %1%") % output);
                        }
                      out.close();
                    }
                }
              else
                {
                  return printCommandLineError(Msg("Expecting an output file with a name ending with '.aut' or '.ddaut', but I read %1%") % output);
                }
            }
        }
      else
        {
          if(!toAutFile(std::cout, fsm, true))
            {
              return printCommandLineError("Error when dumping the deterministic automaton in 'aut' format ");
            }
        }
      return SUCCESS;
    }
                
                
    size_t
    writeFiniteStateMachine(const Diades::Automata::Experimental::ConstManagedDdAutFsm & mfsm,
                            /*

                              const Diades::Automata::Experimental::DdAutFsm & fsm, const Diades::Automata::Experimental::DdAutStateManager & sManager,
                            const Diades::Automata::Experimental::DdAutEventManager & eManager, */
                            const std::string & output,
                            const FileSuffixes & suffixes)
    {
      std::ofstream out;
      if(!output.empty())
        {

          if(suffixes.match(output, "aut"))
            {
              out.open(output);
              if(!out.is_open())
                {
                  return printCommandLineError(Msg("Cannot open and write in the 'aut' file %1%") % output);
                }
              else
                {
                  if(!fsmToAutFile(out, mfsm.fsm, mfsm.eMgr, true))
                    {
                      return printCommandLineError(Msg("Error when dumping the deterministic automaton in the 'aut' file %1%") % output);
                    }
                  out.close();
                }
            }
          else
            {

              if(suffixes.match(output, "ddaut"))
                {
                  out.open(output);
                  if(!out.is_open())
                    {
                      return printCommandLineError(Msg("Cannot open and write in the 'ddaut' file %1%") % output);
                    }
                  else
                    {
                      if(!fsmToDdAutFile(out, mfsm))
                        {
                          return printCommandLineError(Msg("Error when dumping the deterministic automaton in the 'ddaut' file %1%") % output);
                        }
                      out.close();
                    }
                }
              else
                {
                  return printCommandLineError(Msg("Expecting an output file with a name ending with '.aut' or '.ddaut', but I read %1%") % output);
                }
            }
        }
      else
        {
          if(!fsmToDdAutFile(std::cout, mfsm))
            {
              return printCommandLineError("Error when dumping the deterministic automaton in 'ddaut' format ");
            }
        }
      return SUCCESS;
    }
                
    size_t
    writeFiniteAutomaton(const Diades::Automata::Experimental::ConstManagedDdAutFA & mfa, 
                         const std::string & output,
                         const FileSuffixes & suffixes)
    {
      std::ofstream out;
      if(!output.empty())
        {

          if(suffixes.match(output, "aut"))
            {
              out.open(output);
              if(!out.is_open())
                {
                  return printCommandLineError(Msg("Cannot open and write in the 'aut' file %1%") % output);
                }
              else
                {
                  if(!fsmToAutFile(out, mfa.fa, mfa.eMgr, true))
                    {
                      return printCommandLineError(Msg("Error when dumping the deterministic automaton in the 'aut' file %1%") % output);
                    }
                  out.close();
                }
            }
          else
            {

              if(suffixes.match(output, "ddaut"))
                {
                  out.open(output);
                  if(!out.is_open())
                    {
                      return printCommandLineError(Msg("Cannot open and write in the 'ddaut' file %1%") % output);
                    }
                  else
                    {
                      if(!faToDdAutFile(out, mfa))
                        {
                          return printCommandLineError(Msg("Error when dumping the deterministic automaton in the 'ddaut' file %1%") % output);
                        }
                      out.close();
                    }
                }
              else
                {
                  return printCommandLineError(Msg("Expecting an output file with a name ending with '.aut' or '.ddaut', but I read %1%") % output);
                }
            }
        }
      else
        {
          if(!faToDdAutFile(std::cout, mfa))
            {
              return printCommandLineError("Error when dumping the deterministic automaton in 'ddaut' format ");
            }
        }
      return SUCCESS;
    }




    size_t
    checkFileNameSuffix(const std::string & filename, const std::string & suffix)
    {
      if(suffix.find('.') != std::string::npos)
        {
          return printCommandLineError(Msg("Checking a filename for a wrong suffix that contains at least a '.' character: %1%") % filename);
        }
      // note that I do not use FileSuffixes as FileSuffixes does not handle filename with multiple dots
      auto lastDot = filename.find_last_of(".");
      if(lastDot == std::string::npos)
           {
             return printCommandLineError(Msg("Expecting a file with a name ending with '.%2%', but I read %1%") % filename % suffix);
           }
      auto startSuffix = filename.find(suffix,lastDot);
      if(startSuffix ==  std::string::npos)
      {
        return printCommandLineError(Msg("Expecting a file with a name ending with '.%2%'', but I read %1%") % filename % suffix);
      }
      if((filename.length() - startSuffix) != suffix.length())
        {
          return printCommandLineError(Msg("Expecting a file with a name ending with '.%2%', but I read %1%") % filename % suffix);
        }
      return SUCCESS;
    }

    
    size_t
    checkDdAutFileName(const std::string & filename)
    {
      return checkFileNameSuffix(filename,"ddaut");
    }

    size_t isOpenableFile(const std::string & filename)
    {
     
      std::ifstream file(filename.c_str());
      if(!file.is_open())
        {
          return printCommandLineError(Msg("The file %1% cannot be opened.") % filename);
        }
      file.close();
      return SUCCESS;
    }
    
    
    size_t
    checkDdAutFile(const std::string & filename)
    {
      auto result = checkDdAutFileName(filename);
      if(result == SUCCESS)
        {
          return isOpenableFile(filename);
        }
      return result;
    }


    

    size_t
    checkAutFile(const std::string & filename)
    {
      auto result = checkAutFileName(filename);
      if(result == SUCCESS)
        {
          return isOpenableFile(filename);
        }
      return result;
    }


    


    size_t
        checkAutFileName(const std::string & filename)
    {
      return checkFileNameSuffix(filename,"aut");
    }


    
  }
}