magic_application.cpp

Aller à la documentation de ce fichier.

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  MAGiC
//####//  Jean Christophe Cuilliere et Vincent FRANCOIS
//####//  Departement de Genie Mecanique - UQTR
//####//------------------------------------------------------------
//####//  MAGIC est un projet de recherche de l equipe ERICCA
//####//  du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
//####//  http://www.uqtr.ca/ericca
//####//  http://www.uqtr.ca/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       magic_application.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:57 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#include "gestionversion.h"
#include "magic_application.h"
#include <string.h>
#include <stdlib.h>
#include <iostream>
 
 
MAGIC_PARAMETRE_APPLICATION::MAGIC_PARAMETRE_APPLICATION(int n,char* nomparam,int type,char *messaide):num(n),type_parametre(type),valeur_bool(false)
{
strcpy(nom,nomparam);  
strcpy(aide,messaide);
valeur_string[0]=0;
}
 
MAGIC_PARAMETRE_APPLICATION::~MAGIC_PARAMETRE_APPLICATION()
{
 
}
 
MAGIC_PARAMETRE_APPLICATION::MAGIC_PARAMETRE_APPLICATION(MAGIC_PARAMETRE_APPLICATION &mdd):num(mdd.num),type_parametre(mdd.type_parametre),valeur_double(mdd.valeur_double),valeur_int(mdd.valeur_int),action_param_dependant(mdd.action_param_dependant),valeur_bool(mdd.valeur_bool)
{
strcpy(nom,mdd.nom);
strcpy(valeur_string,mdd.valeur_string);
strcpy(aide,mdd.aide);
}
 
MAGIC_PARAMETRE_APPLICATION::MAGIC_PARAMETRE_APPLICATION(const MAGIC_PARAMETRE_APPLICATION &mdd):num(mdd.num),type_parametre(mdd.type_parametre),valeur_double(mdd.valeur_double),valeur_int(mdd.valeur_int),action_param_dependant(mdd.action_param_dependant),valeur_bool(mdd.valeur_bool)
{
strcpy(nom,mdd.nom);
strcpy(valeur_string,mdd.valeur_string);
strcpy(aide,mdd.aide);
}
 
 
 
void MAGIC_PARAMETRE_APPLICATION::ajouter_valeur(double val)
{
if (type_parametre==DOUBLE) valeur_double=val;  
}
 
void MAGIC_PARAMETRE_APPLICATION::ajouter_valeur(bool val)
{
if (type_parametre==BOOL) valeur_bool=val;  
}
void MAGIC_PARAMETRE_APPLICATION::ajouter_valeur(int val)
{
if (type_parametre==INTEGER) valeur_int=val;  
}
 
 
void MAGIC_PARAMETRE_APPLICATION::ajouter_valeur(char* val)
{
if (type_parametre==STRING) strcpy(valeur_string,val);  
}
 
void MAGIC_PARAMETRE_APPLICATION::ajouter_dependance(int numparam)
{
if (type_parametre==ACTION) action_param_dependant.push_back(numparam);  
}
 
char* MAGIC_PARAMETRE_APPLICATION::get_nom(void)
{
return nom;  
}
 
char* MAGIC_PARAMETRE_APPLICATION::get_aide(void)
{
return aide;  
}
 
 
int MAGIC_PARAMETRE_APPLICATION::get_type_parametre(void)
{
return type_parametre;
}
 
int MAGIC_PARAMETRE_APPLICATION::get_valeur_action(void)
{
return num;
}
 
int MAGIC_PARAMETRE_APPLICATION::get_nb_action_param_dependant(void)
{
return action_param_dependant.size();  
}
 
int MAGIC_PARAMETRE_APPLICATION::get_action_param_dependant(int i)
{
return action_param_dependant[i];  
}
 
char* MAGIC_PARAMETRE_APPLICATION:: get_string(void)
{
return valeur_string  ;
}
int  MAGIC_PARAMETRE_APPLICATION::get_num(void)
{
return num;  
}
int  MAGIC_PARAMETRE_APPLICATION::get_int(void)
{
return valeur_int;  
}
double MAGIC_PARAMETRE_APPLICATION:: get_double(void)
{
return valeur_double;  
}
bool  MAGIC_PARAMETRE_APPLICATION::get_bool(void)
{
return valeur_bool;  
}
 
MAGIC_APPLICATION::MAGIC_APPLICATION(char *description,char argc,char **argv,std::vector<MAGIC_PARAMETRE_APPLICATION> &lst,bool avecin,bool avecout):action(-1),action_multiple(false),erreur(false)
{
if (strcmp(argv[argc-1],"--help")==0) 
      {
      affiche(description);
      exit(0);        
      }
cpu.initialise();
time(&debut);
CODE_ASTER_CPU=0;
CODE_ASTER_ECOULE=0;
int num=1;
if (avecin==true) 
  {
  #ifdef USE_ENGLISH
        MAGIC_PARAMETRE_APPLICATION param1(num,(char*)"-in",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Data file");
  #else
        MAGIC_PARAMETRE_APPLICATION param1(num,(char*)"-in",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Fichier d'entrée");
  #endif
  lstparam.push_back(param1);
  num++;
  }
if (avecout==true) 
  {
  #ifdef USE_ENGLISH
        MAGIC_PARAMETRE_APPLICATION param2(num,(char*)"-out",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Result file"); 
  #else
        MAGIC_PARAMETRE_APPLICATION param2(num,(char*)"-out",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Fichier de sortie"); 
  #endif
  lstparam.push_back(param2);
  }
for (int i=0;i<lst.size();i++)
  {
  lstparam.push_back(lst[i]);
  if (lst[i].get_type_parametre()==MAGIC_PARAMETRE_APPLICATION::ACTION) action_multiple=true;
    
  }
 
 
std::vector<int> lstargv(argc);
for (int i=0;i<argc;i++)
  lstargv[i]=0;
for (int i=0;i<argc;i++)
  for (int j=0;j<lstparam.size();j++)
          if (strcmp(argv[i],lstparam[j].get_nom())==0) 
          {
          lstargv[i]=1;
      MAGIC_PARAMETRE_APPLICATION p=lstparam[j];
          if (lstparam[j].get_type_parametre()==MAGIC_PARAMETRE_APPLICATION::ACTION) {action=p.get_valeur_action();strcpy(nomaction,p.get_nom());strcpy(descripaction,p.get_aide());}
          if (lstparam[j].get_type_parametre()==MAGIC_PARAMETRE_APPLICATION::INTEGER) 
            {
            #ifdef USE_ENGLISH
                if (i+2>argc) affiche_erreur((char*)"Syntax error");
            #else
                if (i+2>argc) affiche_erreur((char*)"Erreur de syntaxe");
            #endif
            else {p.ajouter_valeur(atoi(argv[i+1]));lstargv[i+1]=1;}
            }
          if (lstparam[j].get_type_parametre()==MAGIC_PARAMETRE_APPLICATION::DOUBLE) 
            {
            #ifdef USE_ENGLISH
                if (i+2>argc) affiche_erreur((char*)"Syntax error");
            #else
                if (i+2>argc) affiche_erreur((char*)"Erreur de syntaxe");
            #endif
            else {p.ajouter_valeur(atof(argv[i+1]));lstargv[i+1]=1;}
            }
          if (lstparam[j].get_type_parametre()==MAGIC_PARAMETRE_APPLICATION::STRING) 
            {
            #ifdef USE_ENGLISH
                if (i+2>argc) affiche_erreur((char*)"Syntax error");
            #else
                if (i+2>argc) affiche_erreur((char*)"Erreur de syntaxe");
            #endif
            else {p.ajouter_valeur(argv[i+1]);lstargv[i+1]=1;}
            }
          if (lstparam[j].get_type_parametre()==MAGIC_PARAMETRE_APPLICATION::BOOL) p.ajouter_valeur(true);
          if (lstparam[j].get_type_parametre()!=MAGIC_PARAMETRE_APPLICATION::ACTION) lstparampresent.push_back(p);
          }
char version[500];
affiche((char*)"\033[1;36m************************************************************");
sprintf(version,"*                        MAGiC %s                        *",MAGIC_VERSION);
affiche(version);
affiche((char*)"************************************************************");
GESTIONVERSION v;
v.print(version);
affiche(version);
affiche((char*)"************************************************************");
char lignecommande[5000];
strcpy(lignecommande,argv[0]);
for (int i=1;i<argc;i++)
    {
    if (lstargv[i]==1) 
        sprintf(lignecommande,"%s %s",lignecommande,argv[i]);    
    else
        sprintf(lignecommande,"%s \033[1;31m%s\033[1;36m",lignecommande,argv[i]);    
    }
affiche(lignecommande);
affiche((char*)"************************************************************");
affiche(description);
affiche((char*)"************************************************************\033[1;33m");
 
 
if (lstparampresent.size()==0)
    {
    erreur=true;
    if (action==-1)
        {
        #ifdef USE_ENGLISH
        if (!action_multiple) affiche((char*)"List of parameters");
        else affiche((char*)"List of actions");
        #else
        if (!action_multiple) affiche((char*)"Liste des paramètres disponibles");
        else affiche((char*)"Liste des actions disponibles");
        #endif
        for (int j=0;j<lstparam.size();j++)
          {
          char mess[255];
          if (lstparam[j].get_type_parametre()==MAGIC_PARAMETRE_APPLICATION::INTEGER) sprintf(mess,"  %s integer: %s",lstparam[j].get_nom(),lstparam[j].get_aide());
          if (lstparam[j].get_type_parametre()==MAGIC_PARAMETRE_APPLICATION::DOUBLE) sprintf(mess,"  %s double: %s",lstparam[j].get_nom(),lstparam[j].get_aide());
          if (lstparam[j].get_type_parametre()==MAGIC_PARAMETRE_APPLICATION::STRING) sprintf(mess,"  %s chaine: %s",lstparam[j].get_nom(),lstparam[j].get_aide());
          if (lstparam[j].get_type_parametre()==MAGIC_PARAMETRE_APPLICATION::BOOL) sprintf(mess,"  %s : %s",lstparam[j].get_nom(),lstparam[j].get_aide());
          if (lstparam[j].get_type_parametre()==MAGIC_PARAMETRE_APPLICATION::ACTION) sprintf(mess,"  %s : %s",lstparam[j].get_nom(),lstparam[j].get_aide());
          if (!action_multiple) affiche(mess);
          if ((action_multiple) &&(lstparam[j].get_type_parametre()==MAGIC_PARAMETRE_APPLICATION::ACTION)) affiche(mess);
          }
        }
    else
        {
        char mess[2000];
        #ifdef USE_ENGLISH
        sprintf(mess,"List of parameter for action %s\nDescription : %s",nomaction,descripaction);
        #else
        sprintf(mess,"Liste des paramètres disponible pour l'action %s\nDescription : %s",nomaction,descripaction);
        #endif
        affiche(mess);
        for (int j=0;j<lstparam[action-1].get_nb_action_param_dependant();j++)
          {
          char mess[255];
          MAGIC_PARAMETRE_APPLICATION p=lstparam[lstparam[action-1].get_action_param_dependant(j)-1];
          if (p.get_type_parametre()==MAGIC_PARAMETRE_APPLICATION::INTEGER) sprintf(mess,"  %s integer: %s",p.get_nom(),p.get_aide());
          if (p.get_type_parametre()==MAGIC_PARAMETRE_APPLICATION::DOUBLE) sprintf(mess,"  %s double: %s",p.get_nom(),p.get_aide());
          if (p.get_type_parametre()==MAGIC_PARAMETRE_APPLICATION::STRING) sprintf(mess,"  %s chaine: %s",p.get_nom(),p.get_aide());
          if (p.get_type_parametre()==MAGIC_PARAMETRE_APPLICATION::BOOL) sprintf(mess,"  %s : %s",p.get_nom(),p.get_aide());
          if (p.get_type_parametre()==MAGIC_PARAMETRE_APPLICATION::ACTION) sprintf(mess,"  %s : %s",p.get_nom(),p.get_aide());
          affiche(mess);
          }
          
        }
    }
}
 
MAGIC_APPLICATION::~MAGIC_APPLICATION()
{
cpu.ajouter_etape("fin");
time_t fin;
time(&fin);
double ecoule=difftime(fin,debut)-CODE_ASTER_ECOULE;
affiche((char*)"\033[1;32m************************************************************");
char version[500];
double tps;
cpu.get_total(1,tps);
  sprintf(version,"   MAGiC %s                          ",MAGIC_VERSION);
  sprintf(version+20,"-       CPU                          ");
  sprintf(version+40,"-      ECOULE                          ");
affiche(version);
if (CODE_ASTER_CPU>0)
  {
  sprintf(version,"   Total MAGiC                        ");
  sprintf(version+20,": \033[1;31m%.2lfs\033[1;32m                              ",tps);
  sprintf(version+54,": \033[1;31m%.0lfs\033[1;32m                              ",ecoule);
  affiche(version);
if (CODE_ASTER_CPU>0)
  {
  //sprintf(version,"         Total Code Aster  : \033[1;31m%.2lfs\033[1;32m \t : \033[1;31m%.0lfs\033[1;32m ",CODE_ASTER_CPU,CODE_ASTER_ECOULE);
  sprintf(version,"   Total Code Aster  :                 ");
  sprintf(version+20,": \033[1;31m%.2lfs\033[1;32m                               ",CODE_ASTER_CPU);
  sprintf(version+54,": \033[1;31m%.0lfs\033[1;32m                               ",CODE_ASTER_ECOULE);
  affiche(version);
  }
    
  }
  sprintf(version,"   Total                                 ");
  sprintf(version+20,": \033[1;31m%.2lfs\033[1;32m                                ",CODE_ASTER_CPU+tps);
  sprintf(version+54,": \033[1;31m%.0lfs\033[1;32m                                ",ecoule+CODE_ASTER_ECOULE);
affiche(version);
affiche((char*)"************************************************************\033[00m");
}
 
 
MAGIC_APPLICATION::MAGIC_APPLICATION(MAGIC_APPLICATION &mdd)
{
}
 
MAGIC_PARAMETRE_APPLICATION MAGIC_APPLICATION::get_param_present(int num)
{
for (int i=0;i<lstparampresent.size();i++) 
  if (num==lstparampresent[i].get_num()) return lstparampresent[i];
MAGIC_PARAMETRE_APPLICATION p(-1,(char*)"",MAGIC_PARAMETRE_APPLICATION ::BOOL,(char*)"");
return p;
}
 
MAGIC_PARAMETRE_APPLICATION MAGIC_APPLICATION::get_param(int num)
{
for (int i=0;i<lstparam.size();i++) 
  if (num==lstparam[i].get_num()) return lstparam[i];
MAGIC_PARAMETRE_APPLICATION p(-1,(char*)"",MAGIC_PARAMETRE_APPLICATION ::BOOL,(char*)"");
return p;
}
void MAGIC_APPLICATION::affiche_erreur(char* mess)
{
erreur=true;
affiche(mess);
}
 
 
void MAGIC_APPLICATION::recupere_parametre_string(int num,char *param,char *messerreur,int avec_verif)
{
MAGIC_PARAMETRE_APPLICATION p=get_param_present(num);
if (p.get_num()!=-1)
  {
  strcpy(param,p.get_string());
  if (avec_verif==2)
        {
        FILE *in=fopen(param,"rt");
        if (in!=NULL) fclose(in); 
        else
            {
            char message[500];
            #ifdef USE_ENGLISH
            sprintf(message,"File %s does not exist",param);
            #else
            sprintf(message,"Fichier %s n'existe pas",param);
            #endif
            affiche_erreur(message);
            }
        }
  }
else if (avec_verif>0)
  {
  MAGIC_PARAMETRE_APPLICATION p=get_param(num);
  char message[500];
  #ifdef USE_ENGLISH
  sprintf(message,"parameter %s missing : %s",p.get_nom(),messerreur);
  #else
  sprintf(message,"parametre %s manquant : %s",p.get_nom(),messerreur);
  #endif
  affiche_erreur(message);
  }
}
 
void MAGIC_APPLICATION::recupere_parametre_string_avec_defaut(int num,char *param,char *defaut,int avec_verif)
{
MAGIC_PARAMETRE_APPLICATION p=get_param_present(num);
if (p.get_num()!=-1) 
    {
    strcpy(param,p.get_string());
     if (avec_verif==2)
        {
        FILE *in=fopen(param,"rt");
        if (in!=NULL) fclose(in); 
        else
            {
            char message[500];
            #ifdef USE_ENGLISH
            sprintf(message,"File %s does not exist",param);
            #else
            sprintf(message,"Fichier %s n'existe pas",param);
            #endif
            affiche_erreur(message);
            }
        }
    
    }
else strcpy(param,defaut);
}
 
 
void MAGIC_APPLICATION::recupere_parametre_int(int num,int &val,char* messerreur,int avec_verif)
{
MAGIC_PARAMETRE_APPLICATION p=get_param_present(num);
if (p.get_num()!=-1) 
  val=p.get_int();
else if (avec_verif==1)
  {
  MAGIC_PARAMETRE_APPLICATION p=get_param(num);
  char message[500];
  #ifdef USE_ENGLISH
  sprintf(message,"parameter %s missing : %s",p.get_nom(),messerreur);
  #else
  sprintf(message,"parametre %s manquant : %s",p.get_nom(),messerreur);
  #endif
  affiche_erreur(message);
  }
}
 
void MAGIC_APPLICATION::recupere_parametre_int_avec_defaut(int num,int &val,int defaut)
{
MAGIC_PARAMETRE_APPLICATION p=get_param_present(num);
if (p.get_num()!=-1) 
  val=p.get_int();
else val=defaut;  
}
 
void MAGIC_APPLICATION:: recupere_parametre_double(int num,double &val,char* messerreur,int avec_verif)
{
MAGIC_PARAMETRE_APPLICATION p=get_param_present(num);
if (p.get_num()!=-1) 
  val=p.get_double();
else if (avec_verif==1)
  {
  MAGIC_PARAMETRE_APPLICATION p=get_param(num);
  char message[500];
  #ifdef USE_ENGLISH
  sprintf(message,"parameter %s missing : %s",p.get_nom(),messerreur);
  #else
  sprintf(message,"parametre %s manquant : %s",p.get_nom(),messerreur);
  #endif
  affiche_erreur(message);
  }
  
}
 
void MAGIC_APPLICATION::recupere_parametre_double_avec_defaut(int num,double &val,double defaut)
{
MAGIC_PARAMETRE_APPLICATION p=get_param_present(num);
if (p.get_num()!=-1) 
  val=p.get_double();
else val=defaut;  
  
}
void MAGIC_APPLICATION::recupere_parametre_bool(int num,bool &val,char* messerreur,int avec_verif)
{
MAGIC_PARAMETRE_APPLICATION p=get_param_present(num);
if (p.get_num()!=-1) 
  val=p.get_bool();
else if (avec_verif==1)
  {
  MAGIC_PARAMETRE_APPLICATION p=get_param(num);
  char message[500];
  #ifdef USE_ENGLISH
  sprintf(message,"parameter %s missing : %s",p.get_nom(),messerreur);
  #else
  sprintf(message,"parametre %s manquant : %s",p.get_nom(),messerreur);
  #endif
  affiche_erreur(message);
  }
  
}
void MAGIC_APPLICATION::recupere_parametre_bool_avec_defaut(int num,bool &val,bool defaut)
{
MAGIC_PARAMETRE_APPLICATION p=get_param_present(num);
if (p.get_num()!=-1) 
  val=p.get_bool();
else val=defaut;  
  
}
 
 
void MAGIC_APPLICATION::change_action(int val)
{
action=val;  
}
 
int MAGIC_APPLICATION::get_action(void)
{
return action;  
}
 
 
bool MAGIC_APPLICATION::get_erreur(void)
{
return erreur;  
}
 
void MAGIC_APPLICATION::affiche(char* message)
{
std::cout << message << std::endl;
std::cout.flush();
}