src/DSC/DSC_User/Datastream/Calcium/Copy2UserSpace.hxx

   1 // Copyright (C) 2007-2020  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 //  File   : Copy2UserSpace.hxx
  24 //  Author : Eric Fayolle (EDF)
  25 //  Module : KERNEL
  26 // Modified by : $LastChangedBy$
  27 // Date        : $LastChangedDate: 2007-02-13 11:09:09 +0100 (mar, 13 fév 2007) $
  28 // Id          : $Id$
  29 //
  30 #ifndef _COPY_TO_USER_SPACE_HXX_
  31 #define _COPY_TO_USER_SPACE_HXX_
  32
  33 #include <string>
  34 #include <iostream>
  35 #include "CalciumPortTraits.hxx"
  36
  37 #include <cstdio>
  38
  39 //#define MYDEBUG
  40
  41 //Les demandes de copies vers l'espace utilisateur
  42 //proviennent d'une procédure de lecture
  43
  44
  45 //Cas du zero copie
  46 template <bool zerocopy, typename DataManipulator >
  47 struct Copy2UserSpace{
  48
  49   template <class T1, class T2>
  50   static void apply( T1 * & data, T2 & corbaData, size_t /*nRead*/ ){
  51
  52      typedef typename DataManipulator::InnerType       InnerType;
  53
  54     // OLD:Devient propriétaire des données contenues dans la structure CORBA
  55     // OLD:(allouées par allocbuff() pour une séquence)
  56     // OLD:Le client est propriétaire des données.
  57     // OLD:Il doit cependant être attentif au fait que s'il les modifie,
  58     // OLD:une nouvelle demande de lecture lui fournira les données modifiées.
  59     // OLD:TODO : Si plusieurs lecteurs demandent la même donnée,
  60     // OLD:       ? qui devient le propriétaire? --> Forcément le premier car
  61     // OLD:       ensuite la séquence n'est plus propriétaire et rendra un pointeur NULL.
  62     // OLD:     NO: Le port devrait resté propriétaire du contenu de la séquence
  63     // OLD:     NO: L'utilisateur doit de toute les façons utiliser les données reçues en
  64     // OLD:     NO: lecture seulement car si une nouvelle demande de lecture est formulée
  65     // OLD:     NO: pour ces données, les eventuelles modifications seraient visibles !
  66     // OLD:YES : La solution de donner la propriété à l'utilisateur est convenable car si
  67     // OLD:le port déréférence ces données (garbage collecteur, niveau) le buffer
  68     // OLD:reste disponible à l'ulisateur en lecture et écriture
  69     // OLD:Le problème est que la donnée CORBA stockée par le port est maintenant vide (cf CORBA BOOK)
  70     // OLD:du coup quid d'une nouvelle demande de lecture : A TESTER
  71
  72      // Le PORT doit être capable de répondre aux demandes de lecture
  73      // multiples d'une donnée pour une même estampille et doit donc garder un pointeur valide
  74      // sur le buffer. Il se pose cependant un problème s'il décide
  75      // de supprimer la donnée alors que des client utilise le buffer (historique calcium) !
  76      // La seule façon de gérer proprement cette situation est d'utiliser un shared_pointer (TODO).
  77      // Pour l'instant l'utilisateur du mode zero copie doit s'assurer que le niveau d'historique
  78      // utilisé par le port est compatible avec son utilisation des buffers. Il doit
  79      // être également conscient que s'il modifie le buffer, il est modifié pour tous les
  80      // utilisateurs actuels et futurs.
  81
  82      //REF:    InnerType * dataPtr  = DataManipulator::getPointer(corbaData,true);
  83      // Laisse la propriété des données à la structure CORBA
  84      // (buffer allouée par allocbuff() pour une séquence)
  85      InnerType * dataPtr  = DataManipulator::getPointer(corbaData,false);
  86
  87     // Cette ligne poserait uun problème dans la méthode appelante, si elle
  88     // ne testait pas que les types utilisateurs et CORBA sont identiques :
  89     // ex :  InnerType == Corba::Long et d'un T == int
  90     // C'est l'objet de la spécialisation ci-dessous.
  91     data = dataPtr;
  92
  93     // En zero copie l'utilisateur doit appeler ecp_free ( cas ou un buffer intermédiaire
  94     // a été alloué pour cause de typage différent xor necessité de désalouer le buffer alloué par CORBA)
  95     // L'utilisateur doit cependant être attentif au fait qu'après désallocation, si la donnée
  96     // est toujours estampillée dans le port une nouvelle lecture pour cette estampille
  97     // rendrait un buffer vide.
  98   }
  99 };
 100
 101 // Cas où il faut effectuer une recopie
 102 template <typename DataManipulator>
 103 struct Copy2UserSpace<false, DataManipulator> {
 104
 105   //Recopie le contenu de la donnée CORBA dans le buffer utilisateur de longueur nRead
 106   template <class T1, class T2>
 107   static void apply( T1 * &data, T2 & corbaData, size_t nRead){
 108
 109     typedef typename DataManipulator::InnerType        InnerType;
 110
 111
 112 #ifdef MYDEBUG
 113     InnerType * dataPtr = NULL;
 114     // Affiche la valeur du pointeur de la structure corba
 115     //  et les pointeurs contenus le cas échéant
 116     dataPtr  = DataManipulator::getPointer(corbaData,false);
 117     std::cerr << "-------- Copy2UserSpace<false> MARK 1a --dataPtr("<<dataPtr<<")[0.."<<
 118       DataManipulator::size(corbaData) <<"] : ----------------" << std::endl;
 119     std::copy(dataPtr,dataPtr+DataManipulator::size(corbaData),std::ostream_iterator<T1>(std::cerr," "));
 120     for (int i=0; i< DataManipulator::size(corbaData); ++i)
 121       fprintf(stderr,"pointer[%d]=%p ",i, dataPtr[i]);
 122     std::cerr << std::endl;
 123
 124     T1 * tmpData = data;
 125     //Cette affichage peut provoquer la détection d'écriture d'un espace non initailisé.
 126     std::cerr << "-------- Copy2UserSpace<false> MARK 1b --data("<<tmpData<<")[0.."<<
 127       DataManipulator::size(corbaData) <<"] : ----------------" << std::endl;
 128     std::copy(tmpData,tmpData+DataManipulator::size(corbaData),std::ostream_iterator<T1>(std::cerr," "));
 129     for (int i=0; i< DataManipulator::size(corbaData); ++i)
 130       fprintf(stderr,"pointer[%d]=%p ",i, tmpData[i]);
 131     std::cerr << std::endl;
 132 #endif
 133
 134     // Pour les types pointeurs et ref il faut effectuer une recopie profonde.
 135     // On la délègue au manipulateur de données.
 136
 137     // Recopie des données dans le buffer allouée par l'utilisateur
 138     // OU
 139     // Recopie des données dans le buffer allouée par la méthode appelante (ex: lecture)
 140     // dans le cas d'une demande utilisateur 0 copie mais que types utilisateurs et CORBA incompatibles.
 141
 142     //std::copy(dataPtr,dataPtr+nRead,data);
 143     DataManipulator::copy(corbaData,data,nRead);
 144
 145 #ifdef MYDEBUG
 146     tmpData = data;
 147     std::cerr << "-------- Copy2UserSpace<false> MARK 1c --data("<<tmpData<<")[0.."<<
 148       DataManipulator::size(corbaData) <<"] : ----------------" << std::endl;
 149     std::copy(tmpData,tmpData+DataManipulator::size(corbaData),std::ostream_iterator<T1>(std::cerr," "));
 150     for (int i=0; i< DataManipulator::size(corbaData); ++i)
 151       fprintf(stderr,"pointer[%d]=%p ",i, tmpData[i]);
 152     std::cerr << std::endl;
 153 #endif
 154
 155   }
 156
 157 };
 158
 159
 160 // Désallocation des buffers si necessaire
 161 template <bool rel, typename DataManipulator >
 162 struct DeleteTraits {
 163   template <typename T>
 164   static void apply(T * /*dataPtr*/) {
 165
 166     typedef typename DataManipulator::Type         DataType; // Attention != T
 167
 168     // Attention : Seul CalciumCouplingPolicy via eraseDataId doit décider de supprimer ou non
 169     // la donnée corba associée à un DataId !
 170     // Ne pas effectuer la desallocation suivante :
 171     // DataManipulator::relPointer(dataPtr);
 172   }
 173 };
 174
 175 // Désalocation du buffer intermédiaire
 176 // dans le cas d'un type Utilisateur différent du type CORBA
 177 template <typename DataManipulator>
 178 struct DeleteTraits< false, DataManipulator > {
 179
 180   template <typename T>
 181   static void apply(T * dataPtr) { delete[] dataPtr; }
 182
 183 };
 184
 185 #endif