src/Batch/Batch_Versatile.cxx

   1 /*
   2  * Versatile.cxx :
   3  *
   4  * Auteur : Ivan DUTKA-MALEN - EDF R&D
   5  * Date   : Septembre 2003
   6  * Projet : SALOME 2
   7  *
   8  */
   9
  10 #include <iostream>
  11 #include <list>
  12 #include <string>
  13 #include <sstream>
  14 //#include "MEDMEM_STRING.hxx"
  15 #include "Batch_GenericType.hxx"
  16 #include "Batch_IntType.hxx"
  17 #include "Batch_BoolType.hxx"
  18 #include "Batch_CharType.hxx"
  19 #include "Batch_LongType.hxx"
  20 #include "Batch_StringType.hxx"
  21 #include "Batch_Versatile.hxx"
  22 #include "Batch_TypeMismatchException.hxx"
  23 #include "Batch_ListIsFullException.hxx"
  24 using namespace std;
  25
  26 namespace Batch {
  27
  28         // Constructeur par recopie
  29   Versatile::Versatile(const Versatile & V) : _discriminator(V._discriminator), _maxsize(V._maxsize), _name(V._name) // , _str_value(0)
  30   {
  31     Versatile::const_iterator it;
  32
  33                 // On prend un a un les elements de l'objet passe en argument qu'on duplique
  34     for(it=V.begin(); it!=V.end(); it++)
  35       push_back( (*it)->clone() ); // Attention, la methode clone fait un new implicite
  36   }
  37
  38         // Destructeur
  39   Versatile::~Versatile()
  40   {
  41                 eraseAll();
  42   }
  43
  44         // Operateur d'affectation entre objets
  45   Versatile & Versatile::operator = (const Versatile & Vrhs) throw(TypeMismatchException)
  46   {
  47                 // ATTENTION : le forçage de type leve une exception TypeMismatchException entre cas de conflit
  48     setType(Vrhs._discriminator);
  49     setMaxSize(Vrhs._maxsize);
  50     _name = Vrhs._name;
  51
  52     // On efface les donnees precedentes
  53     eraseAll();
  54
  55     // On copie les donnees de Vrhs
  56     Versatile::const_iterator it;
  57
  58     for(it=Vrhs.begin(); it!=Vrhs.end(); it++)
  59       push_back( (*it)->clone() ); // Attention, la methode clone fait un new implicite
  60
  61     return *this;
  62   }
  63
  64         // Operateur d'affectation a partir d'un long
  65   Versatile & Versatile::operator = (const long   l) throw(TypeMismatchException)
  66   {
  67                 // ATTENTION : le forçage de type leve une exception TypeMismatchException entre cas de conflit
  68     setType(LONG);
  69
  70     // On efface les donnees precedentes
  71     eraseAll();
  72
  73                 // On ajoute un element interne de type long a l'objet
  74     LongType * pL = new LongType(l);
  75     assert(pL != 0);
  76     push_back(pL);
  77     return *this;
  78   }
  79
  80         // Operateur d'affectation a partir d'une string
  81   Versatile & Versatile::operator = (const string & ch) throw(TypeMismatchException)
  82   {
  83                 // ATTENTION : le forçage de type leve une exception TypeMismatchException entre cas de conflit
  84     setType(STRING);
  85
  86     // On efface les donnees precedentes
  87     eraseAll();
  88
  89                 // On ajoute un element interne de type string a l'objet
  90     StringType * pS = new StringType(ch);
  91     assert(pS != 0);
  92     push_back(pS);
  93
  94     return *this;
  95   }
  96
  97         // Operateur de concatenation a partir d'une string
  98   Versatile & Versatile::operator +=(const string & ch) throw(TypeMismatchException,ListIsFullException)
  99   {
 100                 // ATTENTION : le forçage de type leve une exception TypeMismatchException entre cas de conflit
 101     setType(STRING);
 102
 103                 // Si la taille maximale est atteinte, on leve une exception ListIsFullException
 104     if (_maxsize == 0) push_back(new StringType(ch));
 105     else if ((_maxsize > 0) && (size() < _maxsize)) push_back(new StringType(ch));
 106     else {
 107       //MEDMEM::STRING msg;
 108       ostringstream msg;
 109       msg << "Taille maximum : " << _maxsize;
 110       throw(ListIsFullException(msg.str()));
 111     }
 112     return *this;
 113   }
 114
 115         // Operateur de concatenation a partir d'une string
 116   Versatile & Versatile::operator , (const string & ch) throw(TypeMismatchException,ListIsFullException)
 117   {
 118     *this += ch;
 119     return *this;
 120   }
 121
 122         // Operateur d'affectation a partir d'un Couple
 123   Versatile & Versatile::operator = (const Couple & cp) throw(TypeMismatchException)
 124   {
 125                 // ATTENTION : le forçage de type leve une exception TypeMismatchException entre cas de conflit
 126                 setType(COUPLE);
 127
 128     // On efface les donnees precedentes
 129     eraseAll();
 130
 131                 // On ajoute un element interne de type Couple a l'objet
 132     CoupleType * pC = new CoupleType(cp);
 133     assert(pC != 0);
 134     push_back(pC);
 135
 136     return *this;
 137   }
 138
 139         // Operateur de concatenation a partir d'un Couple
 140   Versatile & Versatile::operator +=(const Couple & cp) throw(TypeMismatchException,ListIsFullException)
 141   {
 142                 // ATTENTION : le forçage de type leve une exception TypeMismatchException entre cas de conflit
 143     setType(COUPLE);
 144
 145                 // Si la taille maximale est atteinte, on leve une exception ListIsFullException
 146     if (_maxsize == 0) push_back(new CoupleType(cp));
 147     else if ((_maxsize > 0) && (size() < _maxsize)) push_back(new CoupleType(cp));
 148     else {
 149       //MEDMEM::STRING msg;
 150       ostringstream msg;
 151       msg << "Taille maximum : " << _maxsize;
 152       throw(ListIsFullException(msg.str()));
 153     }
 154     return *this;
 155   }
 156
 157         // Operateur de concatenation a partir d'un Couple
 158   Versatile & Versatile::operator , (const Couple & cp) throw(TypeMismatchException,ListIsFullException)
 159   {
 160     *this += cp;
 161     return *this;
 162   }
 163
 164   ostream & operator << (ostream & os, const Versatile & V)
 165   {
 166     Versatile::const_iterator it;
 167     char * sep = "";
 168
 169     for(it=V.begin(); it!=V.end(); it++, sep=" ") {
 170       string s = (*it)->affiche();
 171       os << sep << s;
 172     }
 173     return os;
 174   }
 175
 176         // Positionnement du type de l'element interne
 177   void Versatile::setType(DiscriminatorType t) throw(TypeMismatchException)
 178   {
 179                 // Si le type est deja defini et ne correspond pas au type en argument
 180                 // une exception TypeMismatchException est levee
 181     if ( (_discriminator == UNDEFINED) || (_discriminator == t) )
 182       _discriminator = t;
 183     else {
 184       //MEDMEM::STRING sst;
 185       ostringstream sst;
 186       sst << "Trying to change type of Versatile object \""
 187                                         << _name << "\"";
 188       throw(TypeMismatchException(sst.str()));
 189     }
 190   }
 191
 192         // Positionnement du nombre d'elements internes
 193   void Versatile::setMaxSize(int i)
 194   {
 195     _maxsize = i;
 196     if (i <= 0) return;
 197                 // Si la nouvelle taille est inferieure au nombre d'elements deja
 198                 // presents, les elements en surplus sont effaces (troncature)
 199     if (size() > _maxsize)
 200       {
 201                                 int reste = size() - _maxsize;
 202                                 Versatile::iterator it;
 203                                 for(it=end(); (it!=begin()) && reste; it--, reste--)
 204                                         {
 205                                                 delete back();
 206                                                 pop_back();
 207                                         }
 208       }
 209   }
 210
 211
 212         // Conversion de type vers un long
 213   Versatile::operator long() const throw(TypeMismatchException)
 214   {
 215                 // Si le type ne correspond pas ou si la liste contient plus d'un element,
 216                 // la conversion est impossible et une exception TypeMismatchException
 217                 // est levee
 218     if ( (_maxsize != 1) || (_discriminator != LONG) || (size() == 0) ) {
 219       //MEDMEM::STRING sst;
 220       ostringstream sst;
 221       sst << "Cannot cast Versatile object \""
 222                                         << _name << "\" to long";
 223       throw(TypeMismatchException(sst.str()));
 224     }
 225                 return *( static_cast<LongType *>(this->front()) );
 226   }
 227
 228         // Conversion de type vers un Couple
 229   Versatile::operator Couple() const throw(TypeMismatchException)
 230   {
 231                 // Si le type ne correspond pas ou si la liste contient plus d'un element,
 232                 // la conversion est impossible et une exception TypeMismatchException
 233                 // est levee
 234     if ( (_maxsize != 1) || (_discriminator != COUPLE) || (size() == 0) ) {
 235       //MEDMEM::STRING sst;
 236       ostringstream sst;
 237       sst << "Cannot cast Versatile object \""
 238                                         << _name << "\" to Couple";
 239       throw(TypeMismatchException(sst.str()));
 240     }
 241                 return *( static_cast<CoupleType *>(this->front()) );
 242   }
 243
 244         // Conversion de type vers une string
 245   string Versatile::str() const throw(TypeMismatchException)
 246   {
 247                 // Si le type ne correspond pas, la conversion est impossible et
 248                 // une exception TypeMismatchException est levee
 249     if ( (_discriminator != STRING) || (size() == 0) ) {
 250       //MEDMEM::STRING sst;
 251       ostringstream sst;
 252       sst << "Cannot cast Versatile object \""
 253                                         << _name << "\" to string";
 254       throw(TypeMismatchException(sst.str()));
 255     }
 256
 257                 // La chaine renvoyee est la concatenation des chaines internes
 258     string s;
 259     Versatile::const_iterator it;
 260     const char * sep = "";
 261     for(it=begin(); it!=end(); it++, s+=sep, sep=" ")
 262       s += *( static_cast<StringType *>(*it));
 263
 264     return s;
 265   }
 266
 267         // Conversion de type vers une string
 268   Versatile::operator string () const throw(TypeMismatchException)
 269   {
 270     return str();
 271   }
 272
 273         // Efface tous les elements internes de l'objet
 274   void Versatile::eraseAll()
 275   {
 276     while(!empty())
 277       {
 278                                 delete back();
 279                                 pop_back();
 280       }
 281   }
 282
 283
 284         // Recuperation du type de l'element interne
 285   DiscriminatorType Versatile::getType() const
 286   {
 287     return _discriminator;
 288   }
 289
 290         // Recuperation du nom de l'objet
 291   string Versatile::getName() const
 292   {
 293     return _name;
 294   }
 295
 296         // Positionnement du nom de l'objet
 297   void Versatile::setName(const string & name)
 298   {
 299     _name = name;
 300   }
 301 }