Back to index

salome-kernel  6.5.0
CalciumCInterface.cxx
Go to the documentation of this file.
00001 // Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
00002 //
00003 // This library is free software; you can redistribute it and/or
00004 // modify it under the terms of the GNU Lesser General Public
00005 // License as published by the Free Software Foundation; either
00006 // version 2.1 of the License.
00007 //
00008 // This library is distributed in the hope that it will be useful,
00009 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00010 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00011 // Lesser General Public License for more details.
00012 //
00013 // You should have received a copy of the GNU Lesser General Public
00014 // License along with this library; if not, write to the Free Software
00015 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
00016 //
00017 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
00018 //
00019 
00020 #include "CalciumCInterface.hxx"
00021 #include "CalciumCxxInterface.hxx"
00022 
00023 #include <stdio.h>
00024 
00025 
00026 //#define MYDEBUG
00027 #ifdef MYDEBUG
00028 #define DEBTRACE(msg) {std::cerr<<std::flush<<__FILE__<<" ["<<__LINE__<<"] : "<<msg<<std::endl<<std::flush;}
00029 #else
00030 #define DEBTRACE(msg)
00031 #endif
00032 
00033 
00034 /* Définition de l'Interface entre l'API C  et l'API C++
00035    L'utilisateur CALCIUM n'a normalement pas a utliser cette interface
00036    En C/C++ il utilisera celle définie dans Calcium.c (calcium.h)
00037    En C++/CORBA directement celle de CalciumCxxInterface.hxx
00038 */
00039 
00040 
00041 #define STAR *
00042 
00043 /* Définition de ecp_lecture_... , ecp_ecriture_..., ecp_free_... */
00044 
00045 /*  Le premier argument est utilisée :
00046     - comme suffixe dans la définition des noms ecp_lecture_ , ecp_ecriture_ et ecp_free_
00047     - comme second argument template à l'appel de la méthode C++ correspondante
00048         ( le type de port correspondant est alors obtenu par un trait)
00049    Le second argument est utilisée :
00050    - pour typer le paramètre data de la procédure générée 
00051    - pour déduire le type des paramètres t, ti tf via un trait
00052    - comme premier paramètre template à l'appel de la méthode C++ correspondante
00053          (pour typer les données passées en paramètre )
00054    Notons que dans le cas CALCIUM_C2CPP_INTERFACE_(int,int,), le type int n'existe pas
00055    en CORBA, le port CALCIUM correspondant utilise une séquence de long. La méthode
00056    C++ CALCIUM de lecture repère cette différence de type et charge 
00057    le manipulateur de données d'effectuer  une recopie (qui fonctionne si les types sont compatibles). 
00058 */
00059 // CALCIUM_C2CPP_INTERFACE_CXX_(_name,_porttype,_type,_qual)
00060 CALCIUM_C2CPP_INTERFACE_CXX_(intc,int,int,);
00061 CALCIUM_C2CPP_INTERFACE_CXX_(long,long,long,);
00062 
00063 CALCIUM_C2CPP_INTERFACE_CXX_(integer,integer,cal_int,);
00064 CALCIUM_C2CPP_INTERFACE_CXX_(int2integer ,integer,  int,);
00065 CALCIUM_C2CPP_INTERFACE_CXX_(long2integer, integer, long,);
00066 
00067 CALCIUM_C2CPP_INTERFACE_CXX_(float,float,float, );
00068 CALCIUM_C2CPP_INTERFACE_CXX_(double,double,double,);
00069 /*  Fonnctionne mais essai suivant pour simplification de Calcium.c CALCIUM_C2CPP_INTERFACE_(bool,bool,);*/
00070 CALCIUM_C2CPP_INTERFACE_CXX_(bool,bool,int,);
00071 CALCIUM_C2CPP_INTERFACE_CXX_(cplx,cplx,float,);
00072 CALCIUM_C2CPP_INTERFACE_CXX_(str,str,char*,);
00073 
00074 /* Définition de ecp_fin */
00075 extern "C" CalciumTypes::InfoType 
00076 ecp_fin_ (void * component, int code) {
00077 
00078   Superv_Component_i * _component = static_cast<Superv_Component_i *>(component); 
00079 
00080   bool provideLastGivenValue = false;
00081   if (code == CalciumTypes::CP_CONT ) provideLastGivenValue = true;
00082 
00083   try {                                                                 
00084     CalciumInterface::ecp_fin( *_component,                             
00085                                provideLastGivenValue); 
00086   } catch ( const CalciumException & ex) { //tester l'arrêt par exception
00087     DEBTRACE( ex.what() );
00088     return ex.getInfo();                                                
00089   }                                                                     
00090   return CalciumTypes::CPOK;
00091 };
00092 
00093 extern "C" CalciumTypes::InfoType 
00094 ecp_cd_ (void * component, char * instanceName) {
00095   Superv_Component_i * _component = static_cast<Superv_Component_i *>(component); 
00096   std::string name;
00097   CalciumInterface::ecp_cd( *_component,name);
00098   strcpy(instanceName,name.c_str());
00099   return CalciumTypes::CPOK;
00100 }
00101 
00102 // Interface for cleaning
00103 extern "C" CalciumTypes::InfoType 
00104 ecp_fini_ (void * component, char* nomvar, int i)
00105 {
00106   Superv_Component_i * _component = static_cast<Superv_Component_i *>(component); 
00107   try
00108     {
00109       CalciumInterface::ecp_fini( *_component,nomvar,i);
00110     }
00111   catch ( const CalciumException & ex)
00112     {
00113       DEBTRACE( ex.what() );
00114       return ex.getInfo();
00115     }
00116   return CalciumTypes::CPOK;
00117 
00118 }
00119 
00120 extern "C" CalciumTypes::InfoType 
00121 ecp_fint_ (void * component, char* nomvar, float t)
00122 {
00123   Superv_Component_i * _component = static_cast<Superv_Component_i *>(component); 
00124   try
00125     {
00126       CalciumInterface::ecp_fint( *_component,nomvar,t);
00127     }
00128   catch ( const CalciumException & ex)
00129     {
00130       DEBTRACE( ex.what() );
00131       return ex.getInfo();
00132     }
00133   return CalciumTypes::CPOK;
00134 }
00135 
00136 extern "C" CalciumTypes::InfoType 
00137 ecp_effi_ (void * component, char* nomvar, int i)
00138 {
00139   Superv_Component_i * _component = static_cast<Superv_Component_i *>(component); 
00140   try
00141     {
00142       CalciumInterface::ecp_effi( *_component,nomvar,i);
00143     }
00144   catch ( const CalciumException & ex)
00145     {
00146       DEBTRACE( ex.what() );
00147       return ex.getInfo();
00148     }
00149   return CalciumTypes::CPOK;
00150 
00151 }
00152 
00153 extern "C" CalciumTypes::InfoType 
00154 ecp_efft_ (void * component, char* nomvar, float t)
00155 {
00156   Superv_Component_i * _component = static_cast<Superv_Component_i *>(component); 
00157   try
00158     {
00159       CalciumInterface::ecp_efft( *_component,nomvar,t);
00160     }
00161   catch ( const CalciumException & ex)
00162     {
00163       DEBTRACE( ex.what() );
00164       return ex.getInfo();
00165     }
00166   return CalciumTypes::CPOK;
00167 }
00168 
00169 // INTERFACE C/CPP pour les chaines de caractères
00170 // Le paramètre supplémentaire strsize n'étant pas utilisé
00171 // j'utilise la génération par la macro CALCIUM_C2CPP_INTERFACE_(str,char*,);
00172 // extern "C" CalciumTypes::InfoType ecp_lecture_str (void * component, int dependencyType, 
00173 //                                                 float * ti, float * tf, long * i, 
00174 //                                                 const char * const nomvar, size_t bufferLength, 
00175 //                                                 size_t * nRead, char ** *data, size_t strsize ) { 
00176 
00177 //   Superv_Component_i * _component = static_cast<Superv_Component_i *>(component); 
00178 //   double         _ti=*ti;                                            
00179 //   double         _tf=*tf;                                            
00180 //   size_t         _nRead=0;                                           
00181 //   size_t         _bufferLength=bufferLength;                         
00182 //   CalciumTypes::DependencyType dependencyType=                       
00183 //     static_cast<CalciumTypes::DependencyType>(dependencyType);       
00184   
00185 //   // - GERER POINTEUR NULL : NOTHING TODO 
00186 //   // - VERIFIER LA TAILLE DES CHAINES RETOURNEES (ELLES DEVRAIENT ETRES CORRECTES SI L'ECRITURE EST BIEN CODEE.)
00187 
00188 //   DEBTRACE( "-------- CalciumInterface(lecture Inter Part) MARK 1 ------------------" ) 
00189 //     try {                                                            
00190 //       CalciumInterface::ecp_lecture< char*, char* >( *_component,    
00191 //                                                   dependencyType, 
00192 //                                                   _ti, _tf, *i,      
00193 //                                                   nomvar,            
00194 //                                                   _bufferLength, _nRead, *data); 
00195 //     } catch ( const CalciumException & ex) {                         
00196 //       DEBTRACE( ex.what() );
00197 //       return ex.getInfo();                                           
00198 //     }                                                                        
00199     
00200 //     *nRead = _nRead;                                         
00201     
00202 //     if (dependencyType == CalciumTypes::CP_SEQUENTIEL ) 
00203 //       *ti=(float)(_ti);                      
00204     
00205 //     DEBTRACE( "-------- CalciumInterface(lecture Inter Part), Data Ptr :" << *data ) ;
00206 
00207 //     return CalciumTypes::CPOK;
00208 //   };                                                                 
00209                                                                         
00210 
00211 // extern "C" void ecp_lecture_str_free (char** data) { 
00212 //   CalciumInterface::ecp_free< char*, char* >(data);                  
00213 // };                                                                   
00214                                                                         
00215                                                                         
00216 // extern "C" CalciumTypes::InfoType ecp_ecriture_str (void * component, int dependencyType, 
00217 //                                                  float *t, long  i,  
00218 //                                                  const char * const nomvar, size_t bufferLength, 
00219 //                                                  char ** data, int strsize ) { 
00220 
00221 //     Superv_Component_i * _component = static_cast<Superv_Component_i *>(component); 
00222 //     /* Je ne sais pas pourquoi, je n'arrive pas à passer t par valeur : corruption de la pile*/ 
00223 //     double         _t=*t;                                            
00224 //     size_t         _bufferLength=bufferLength;                               
00225 
00226 //     // - VERIFIER LA TAILLE DES CHAINES RETOURNEES (ELLES DEVRAIENT ETRES CORRECTES SI L'ECRITURE EST BIEN CODEE.)
00227 
00228 //     DEBTRACE( "-------- CalciumInterface(ecriture Inter Part) MARK 1 ------------------" ) 
00229 //     try {                                                            
00230 //       std::string essai(nomvar);                                     
00231 //       DEBTRACE( "----------->-" << nomvar )          
00232 //      CalciumInterface::ecp_ecriture< char*, char* >( *_component,    
00233 //                                                      static_cast<CalciumTypes::DependencyType>(dependencyType), 
00234 //                                                      _t,i,nomvar,_bufferLength,*data); 
00235 //     } catch ( const CalciumException & ex) {                         
00236 //       std::cerr << ex.what() << std::endl;                           
00237 //       return ex.getInfo();                                           
00238 //     }                                                                        
00239 //     DEBTRACE( "-------- CalciumInterface(ecriture Inter Part), Valeur de data :" << data ) 
00240 //     return CalciumTypes::CPOK;                                               
00241 //   };