main.cpp

/*
  name: tools/engine/main.cpp

  This file is part of ARCS - Augmented Reality Component System
  (version 2-current), written by Jean-Yves Didier 
  for IBISC Laboratory (http://www.ibisc.univ-evry.fr)

  Copyright (C) 2013  Université d'Evry-Val d'Essonne

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.


  Please send bugreports  with examples or suggestions to
  jean-yves.didier__at__ibisc.univ-evry.fr
*/


#include <arcs/arcsapplicationcomponent.h>
#include <arcs/arcsxmlhandler.h>
#include <arcs/arcslog.h>


void usage(char* name)
{
    std::cout << name << " [OPTION]...  [XML_FILE]..." << std::endl 
        << std::endl;
    std::cout << "  -h,  --help             : print this help" << std::endl << std::endl;
    std::cout << "Overriding application mode : " << std::endl << std::endl;
    std::cout << "  -b,  --mode-base        : simple loop based applications." 
        << std::endl;
    std::cout << "  -e,  --mode-event       : event loop based console applications."
        << std::endl;
    std::cout << "  -g,  --mode-gui         : event loop based GUI applications." 
        << std::endl;
    std::cout << "  -t,  --mode-thread      : threaded application." << std::endl;
    std::cout << "  -te, --mode-thread-event: threaded event based application." << std::endl <<std::endl;
    std::cout << "Defining options:" << std::endl;
    std::cout << "  -d, --define vars       : define constants" << std::endl; 
    std::cout << "  -p, --profile file      : define a profile" << std::endl;
    std::cout << "  -o, --profile-out       : define a file where to dump profile" << std::endl;
    std::cout << "  -l [0-2]                : define output log mode - 0, none; 1, console (default); 2, html" << std::endl;
}


void parseOptions(int argc, char* argv[], ARCS::ARCSAppFlag & flag, QString & constantList, QString & xmlfile, QString & profile, QString& profileOut)
{
     int i=1;
     flag = ARCS::ARCS_APP_NONE;

     for(i=1; i < argc; i++)
     {
          QString current(argv[i]);

          if (current == "-h" || current == "--help")
               usage(argv[0]);
          else
               if (current == "-b" || current == "--mode-base")
                    flag = ARCS::ARCS_APP_BASE;
          else
               if (current == "-e" || current == "--mode-event")
                    flag = ARCS::ARCS_APP_EVENT;
          else
               if (current == "-g" || current == "--mode-gui")
                    flag = ARCS::ARCS_APP_GUI;
          else
               if (current == "-t" || current == "--mode-thread")
                    flag = ARCS::ARCS_APP_THREAD;
          else
               if (current == "-te" || current == "--mode-thread-event")
                    flag = ARCS::ARCS_APP_THREADEVENT;
          else
               if (current == "-l")
               {
                   if (i+1 < argc)
                   {
                       ARCSLog::getInstance()->setLogMode((ARCSLog::LogModes)QString(argv[i+1]).toInt());
                       i++;
                   }
               }

          else
               if (current == "-d" || current == "--define")
               {
               if (i+1 < argc)
               {
                    constantList = argv[i+1];
                    i++;
               }
          }
          else
          {
               if (current == "-p" || current == "--profile")
               {
                    if ( i+1 < argc)
                    {
                         profile = argv[i+1];
                         i++;
                    }
               }
               else
               {
                    if (current == "-o" || current == "--profile-out")
                    {
                         if (i+1  < argc)
                         {
                              profileOut = argv[i+1];
                              i++;
                         }

                    }
                    else
                         xmlfile = argv[i];
               }
          }
     }
}


void parseConstants(QString arglist, ARCSApplicationComponent* app)
{
     int i;
     QStringList lst = arglist.split(":");
     for (i=0; i < lst.count(); i++)
     {
      QStringList lst_2 = lst[i].split("="); // silly windows naming !
      if (lst_2.count() == 2)
          {
           std::cout << "Overriding constant " << qPrintable(lst_2[0])
             << " with value " << qPrintable(lst_2[1]) << std::endl;
           app->changeConstant(lst_2[0], lst_2[1]);
          }
     }
}





int main(int argc, char* argv[])
{
     ARCSApplicationComponent* app = new ARCSApplicationComponent();
     QString xmlfile ;
     QString profileFile;
     QString profileOut;
     ARCS::ARCSAppFlag flag;
     QString constantList;

     parseOptions(argc,argv, flag, constantList, xmlfile,profileFile,profileOut);
     
     if (xmlfile.isEmpty())
     {
          usage(argv[0]);
          return 0;
     }

     if (flag != ARCS::ARCS_APP_NONE)
          app->setCurrentMode(flag);

     if (!app->loadFile(xmlfile)) //parseString(xmlfile))
     {
          std::cerr << "An error occured when trying to load the application" << std::endl;
          return 0;
     }

     std::cout << "Application " << qPrintable(xmlfile) << " loaded."  << std::endl
               << "=================================================="  << std::endl;

     if (!profileFile.isEmpty())
     {
          ARCSXMLHandler* xmlHandler= new ARCSXMLHandler();
          if (xmlHandler->openFile(profileFile))
               if (! xmlHandler->parseProfile(app->getContext()))
                    std::cerr << "Could not read profile file." << std::endl;
          delete xmlHandler;
     }

     
     if (!constantList.isEmpty())
          parseConstants(constantList, app);


     app->startApplication();
     app->wait();
     if (!profileOut.isEmpty())
     {
          ARCSXMLHandler* xmlHandler= new ARCSXMLHandler();
          xmlHandler->storeProfile(app->getContext());
          if (!xmlHandler->saveFile(profileOut))
               std::cerr << "Could not write profile file." << std::endl;
          delete xmlHandler;
     }
    
     return 0;
}