Back to index

salome-kernel  6.5.0
Public Types | Static Public Member Functions
seq_u_manipulation< seq_T, elem_T > Class Template Reference

#include <CorbaTypeManipulator.hxx>

List of all members.

Public Types

typedef seq_T * Type
typedef const seq_T & CorbaInType
typedef elem_T InnerType

Static Public Member Functions

static Type get_data (CorbaInType data)
static size_t size (Type data)
static void delete_data (Type data)
static Type clone (Type data)
static Type clone (CorbaInType data)
static InnerType *const getPointer (Type data, bool ownerShip=false)
static void relPointer (InnerType *dataPtr)
static InnerTypeallocPointer (size_t size)
static Type create (size_t size, InnerType *const data=NULL, bool giveOwnerShip=false)
template<typename T >
static void copy (Type data, T *const idata, size_t isize)
static void copy (Type data, char **const idata, size_t isize)
static void dump (CorbaInType data)

Detailed Description

template<typename seq_T, typename elem_T>
class seq_u_manipulation< seq_T, elem_T >

Definition at line 198 of file CorbaTypeManipulator.hxx.


Member Typedef Documentation

template<typename seq_T, typename elem_T>
typedef const seq_T& seq_u_manipulation< seq_T, elem_T >::CorbaInType

Definition at line 202 of file CorbaTypeManipulator.hxx.

template<typename seq_T, typename elem_T>
typedef elem_T seq_u_manipulation< seq_T, elem_T >::InnerType

Definition at line 203 of file CorbaTypeManipulator.hxx.

template<typename seq_T, typename elem_T>
typedef seq_T* seq_u_manipulation< seq_T, elem_T >::Type

Definition at line 201 of file CorbaTypeManipulator.hxx.


Member Function Documentation

template<typename seq_T, typename elem_T>
static InnerType* seq_u_manipulation< seq_T, elem_T >::allocPointer ( size_t  size) [inline, static]

Definition at line 300 of file CorbaTypeManipulator.hxx.

                                                        {
    return seq_T::allocbuf(size);
  }
template<typename seq_T, typename elem_T>
static Type seq_u_manipulation< seq_T, elem_T >::clone ( Type  data) [inline, static]

Definition at line 269 of file CorbaTypeManipulator.hxx.

                                      {
    return new seq_T (*data) ;
  }
template<typename seq_T, typename elem_T>
static Type seq_u_manipulation< seq_T, elem_T >::clone ( CorbaInType  data) [inline, static]

Definition at line 272 of file CorbaTypeManipulator.hxx.

                                             {
    return new seq_T (data);
  }
template<typename seq_T, typename elem_T>
template<typename T >
static void seq_u_manipulation< seq_T, elem_T >::copy ( Type  data,
T *const  idata,
size_t  isize 
) [inline, static]

Definition at line 324 of file CorbaTypeManipulator.hxx.

                                                                      { 
    
    InnerType *dataPtr  = getPointer(data,false);

    for (int i = 0; i< isize; ++i) 
      idata[i]=dataPtr[i];

    // Le mode de recopie suivant ne permet pas  la conversion de type (ex int -> CORBA::Long)
    //OLD:     Type tmp = new seq_T(isize,isize,idata,false); 
    //OLD:     // giveOwnerShip == false -> seul le contenu du buffer data est détruit et remplacé
    //OLD:     // par celui de data dans l'affectation suivante :
    //OLD:     //       ---> ATTENTION SI LA TAILLE DU BUFFER EST TROP PETITE, QUE FAIT CORBA !
    //OLD:     //              corruption mémoire
    //OLD:     // Cependant ce cas devrait pas arrivé (on s'assure dans les couches supérieures
    //OLD:     //  de la taille correcte du buffer de recopie)
    //OLD:     // Si giveOwnerShip était == true -> le buffer et son contenu serait détruit puis une 
    //OLD:     // allocation de la taille du buffer de data serait effectué avant la copie des données  
    //OLD:     // tmp = data;
  } 

Here is the call graph for this function:

template<typename seq_T, typename elem_T>
static void seq_u_manipulation< seq_T, elem_T >::copy ( Type  data,
char **const  idata,
size_t  isize 
) [inline, static]

Definition at line 349 of file CorbaTypeManipulator.hxx.

                                                                          { 

    char* *dataPtr  = getPointer(data,false);

    // Si idata[i] n'a pas été alloué suffisament grand,
    // il y a corruption de la mémoire
    for (int i = 0; i< isize; ++i) 
      strcpy(idata[i],dataPtr[i]);
  }

Here is the call graph for this function:

template<typename seq_T, typename elem_T>
static Type seq_u_manipulation< seq_T, elem_T >::create ( size_t  size,
InnerType *const  data = NULL,
bool  giveOwnerShip = false 
) [inline, static]

Definition at line 309 of file CorbaTypeManipulator.hxx.

                                                         { 
    Type tmp;
    if (!data) {
      tmp = new seq_T();
      tmp->length(size);
    } else {
      tmp = new seq_T(size,size,data,giveOwnerShip); 
    }
    return tmp;
  } 
template<typename seq_T, typename elem_T>
static void seq_u_manipulation< seq_T, elem_T >::delete_data ( Type  data) [inline, static]

Definition at line 260 of file CorbaTypeManipulator.hxx.

                                            {
    //La séquence est détruite par appel à son destructeur
    //Ce destructeur prend en compte la nécessité de détruire ou non
    //les données contenues en fonction de son flag interne release()
    delete data;
  }

Here is the caller graph for this function:

template<typename seq_T, typename elem_T>
static void seq_u_manipulation< seq_T, elem_T >::dump ( CorbaInType  data) [inline, static]

Definition at line 360 of file CorbaTypeManipulator.hxx.

                                             {
    // Affiche la longueur des donnees
    std::cerr << "[seq_u_manipulation] Data length: " << data.length() << std::endl;
    // Affiche la longueur des donnees
    std::cerr << "[seq_u_manipulation] Data max: " << data.maximum() << std::endl;
  }
template<typename seq_T, typename elem_T>
static Type seq_u_manipulation< seq_T, elem_T >::get_data ( CorbaInType  data) [inline, static]

Definition at line 209 of file CorbaTypeManipulator.hxx.

                                                {
    CORBA::Long len = data.length();
    CORBA::Long max = data.maximum();
    // Récupère et devient propriétaire des données reçues dans la séquence. 
    // La séquence reçue (mais pas le buffer) sera désallouée au retour 
    // de la méthode CORBA qui a reçu le type CorbaInType en paramètre
    // (ex: GenericPort::put)
    // REM : Le mapping CORBA du type séquence IN est : const seq &

    // OLD : On ne teste pas si le flag release de la séquence est à true ou false 
    // OLD : ( pour des séquences de chaines ou d'objrefs )
    // OLD :   -> Si on est collocalisé le port uses doit créer une copie pour éviter la modification
    // OLD : du contenu de la séquence lorsque l'utilisateur modifie ses données dans son programme (0 copie)
    // OLD : ATTENTION TESTER p194 si le pointeur est null (release flag==false)
    // OLD :   -> La séquence n'était pas propriétaire des données !

    // Le flag release() de la séquence est à false si elle n'est pas propriétaire du buffer
    // En  collocalité release() renvoie false car 
    // l'appelé n'est pas propriétaire de la séquence. On effectue alors
    // une copie pour éviter de perturber les structures de données de l'appelant.
    // En non collocalisé on recrée une séquence avec le buffer de la première dont on
    // a demandé la propriété.

#ifdef MYDEBUG
    std::cout << "----seq_u_manipulation::get_data(..)-- MARK 1 ------------------" << std::endl;
#endif
    if ( data.release() ) {
      InnerType * p_data = const_cast<seq_T &>(data).get_buffer(true);

    // Crée une nouvelle sequence propriétaire des données du buffer (pas de recopie)
    // Les données de la nouvelle séquence seront automatiquement désallouées 
    // par appel à la méthode freebuf dans le destructeur de la séquence (cf  delete_data).
#ifdef MYDEBUG
      std::cout << "----seq_u_manipulation::get_data(..)-- MARK 1(0 copy) bis ------"<<  p_data <<"------------" << std::endl;
#endif
    
      return  new seq_T (max, len, p_data, true);
    }
#ifdef MYDEBUG
    std::cout << "----seq_u_manipulation::get_data(..)-- MARK 1(recopie) bis ------"<<  &data <<"------------" << std::endl;
#endif
    // Crée une nouvelle sequence propriétaire des données du buffer (avec recopie)    
    return new seq_T(data);

  }
template<typename seq_T, typename elem_T>
static InnerType* const seq_u_manipulation< seq_T, elem_T >::getPointer ( Type  data,
bool  ownerShip = false 
) [inline, static]

Definition at line 283 of file CorbaTypeManipulator.hxx.

                                                                                {
    InnerType * p_data;
    if (ownerShip) {
      p_data = data->get_buffer(true);
      delete_data(data);
    } else
      p_data = data->get_buffer(false);
    return p_data;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename seq_T, typename elem_T>
static void seq_u_manipulation< seq_T, elem_T >::relPointer ( InnerType dataPtr) [inline, static]

Definition at line 295 of file CorbaTypeManipulator.hxx.

                                                     {
    seq_T::freebuf(dataPtr);
  }
template<typename seq_T, typename elem_T>
static size_t seq_u_manipulation< seq_T, elem_T >::size ( Type  data) [inline, static]

Definition at line 255 of file CorbaTypeManipulator.hxx.

                                       { 
    return data->length();
  } 

The documentation for this class was generated from the following file: