Version: 7.8.0
Copy2UserSpace.hxx
Go to the documentation of this file.
1 // Copyright (C) 2007-2016 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 >
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