---

PsString.cxx

Go to the documentation of this file.

/*
 * This file is part of openMask © INRIA, CNRS, Universite de Rennes 1 1993-2002, thereinafter the Software
 * 
 * The Software has been developped within the Siames Project. 
 * INRIA, the University of Rennes 1 and CNRS jointly hold intellectual property rights
 * 
 * The Software has been registered with the Agence pour la Protection des
 * Programmes (APP) under registration number IDDN.FR.001.510008.00.S.P.2001.000.41200
 *  
 * This file may be distributed under the terms of the Q Public License
 * version 1.0 as defined by Trolltech AS of Norway and appearing in the file
 * LICENSE.QPL included in the packaging of this file.
 *
 * Licensees holding valid specific licenses issued by INRIA, CNRS or Université de Rennes 1 
 * for the software may use this file in accordance with that specific license
 *
 */
#include <PsString.h>
#include <string>

#include <ctype.h> //pour la fonction qui vire les blancs
#include <PsPolator.h>
#include "PsController.h"
#include "PsOutgoingSynchronisationMessage.h"
#include "PsIncomingSynchronisationMessage.h"

#ifdef _MOME
#include <PsnSharedMemoryManager.h>
#include <PsMomeController.h>
#include <PsnMemoryElementDescriptor.h>
#endif
#ifdef _USESSTREAM
#include <sstream>
#else
#include <strstream>
#endif
// Constructors and destructors  **********************************

PsString::PsString ( const string & aString)
{
   _CString = NULL; // Nettoyage de la mémoire
   _nbCarac = strlen( aString.c_str() ) ;
   assert (_nbCarac == aString.length ()) ;
   alloue( _nbCarac );
   // On vérifie que le nombre de caractères est différent de 0
   if (_nbCarac != 0)
      {
       strcpy(_CString, aString.c_str());
       assert (_CString [_nbCarac] == '\0') ;
    }
   else
      {
         _CString[0] = '\0';
      }
}


PsString::PsString (const char *Chn)
{     
   //cerr<<"PsString : constructeur par recopie d'un char *"<<endl;
   if (Chn == NULL)
    {
      cerr << "PsString::PsString(const char*) : " << endl;
      PsController::error("La chaine fournie est un pointeur NULL");
    }
  _CString = NULL; // Nettoyage de la mémoire
  _nbCarac = strlen(Chn);
  alloue(_nbCarac);
  // On vérifie que le nombre de caractères est différent de 0
  if (_nbCarac != 0)
    {
      // On ne copie que si nbCarac != 0
      strcpy(_CString, Chn);
    }
  else
    {
      _CString[0] = '\0';
    }
  //cerr<<_CString<<endl;
  //cerr<<"PsString::recopie terminée pour "<<_CString<<endl;
}


PsString::PsString (const PsString &Chn)
{
   //cerr<<"PsString::PsString (const PsString &Chn)"<<endl;
  _CString = NULL; // Nettoyage de la mémoire
  _nbCarac = Chn.getStringLength();
  alloue(_nbCarac);
  if (_nbCarac != 0)
    {
      // On ne copie que si nbCarac != 0
       strcpy (_CString, Chn._CString);
    }
  else
    {
      _CString[0] = '\0';
    }
  //cerr<<Chn<<endl<<*this<<endl;
}

PsString::PsString (const char Carac)
{
   cerr<<"PsString : construction from a char: "<<Carac<<endl;
  _CString = NULL; // Nettoyage de la mémoire
  _nbCarac = 1;
  alloue(_nbCarac);
  // On copie la caractère et la fin de chaîne
  _CString[0]= Carac;
  _CString[1]= '\0';
}

PsString::~PsString ()
{
   //cerr<<"PsString::~PsString"<<endl;
  // Si la chaîne a été allouée, on la désalloue
  if (_CString != NULL)
    {
       delete [] _CString;
    }
  //cerr<<"PsString::~PsString fini"<<endl;
  //gereVarClasse (Delete);
}

PsPolatorNT * PsString::createPolator (void) {
  return  (PsPolatorNT *) new PsPolator<PsString>();
}
// Recherche dans la chaîne de caractères **********************

int PsString::getSubString(const int debut, const int nbCarac,
                             PsString& sousChaine) const
{
   //assert ( _nbCarac == _tailleMem - 1) ;

   // Nombre de caractères à copier
   int nbMin;
   
   // On vérifie que l'indice de début est bien dans la chaîne
   if ( (debut >= _nbCarac) || (debut < 0) )
      {
      cerr << "WARNING : PsString::getSubString() :" << endl;
      cerr << "Indice de début de sous-chaîne (" << debut
           << ") sort de la chaîne de taille ("
           << _nbCarac << ")" << endl;
      // On n'a pas copié de caractères
      return 0;
    }

  // On regarde s'il veut tout le reste de la chaîne
  if (nbCarac <= 0)
    {
      // On va copier tous les autres caractères
      nbMin = _nbCarac-debut;
    }
  // On détermine le nombre de caractère à fournir en regardant
  // la limite de fin de chaîne
  else if ( (_nbCarac-debut) < nbCarac)
    {
      nbMin = _nbCarac-debut;
    }
  else
    {
      nbMin = nbCarac;
    }
  
  // On vérifie qu'il y a assez de place dans sousChaine
  if (sousChaine._tailleMem <= nbMin)
    {
      // On alloue la place suffisante nbMin+1
      sousChaine.alloue(nbMin);
    }

  // On fait la copie (pas de vérification à cet endroit-là)
  strncpy(sousChaine._CString, _CString+debut, nbMin);

  // On ajoute la fin de chaîne
  sousChaine._CString[nbMin]= '\0';
  sousChaine._nbCarac= nbMin;

  // On renvoie le nombre de caractères copîés
  return nbMin;
}

// PsType * PsString::cloner (void) const {
//    return (new PsString (*this)) ;
// }

int 
PsString::getSubStringIndex (const PsString &cherche) const
{
  if (cherche._nbCarac == 0)
    {
      cerr << "WARNING : PsString::getSubStringIndex() :"
           << "Taille de la sous-chaîne recherchée nulle" << endl;
      return -1;
    }

  char *ptrDebut = strstr(_CString, cherche._CString);
  // A-t-on trouvé la chaîne ?
  if (ptrDebut == NULL)
    {
      // Pas trouvé
      return -1;
    }
  else
    {
      // On a trouvé
      return (ptrDebut - _CString);
    }
}

int
PsString::findCaracter (char Carac) const
{
  char *ptrDebut = strchr(_CString, Carac);
  // A-t-on trouvé la chaîne ?
  if (ptrDebut == NULL)
    {
      // Pas trouvé
      return -1;
    }
  else
    {
      // On a trouvé
      return (ptrDebut - _CString);
    }
}

// Opérateurs unaires ******************************************
char PsString::operator[] (int i) const
{
  if ( (i<0) || (i>=_nbCarac) )
    {
      cerr << "PsString::operator[]: index (" << i << ") hors limite" << endl;
      PsController::error("");
      // Pour la compilation
      return 0;
    }
  else
    {
      return _CString[i];
    }
}

PsString& PsString::operator = (const PsString &Source)
{
   //cerr<<"PsString::operator = "<<*this<<";"<<Source<<endl;
  // On vérifie que ce ne sont pas les mêmes chaînes,
  // sinon c'est fini
  if (_CString != Source._CString)
    {
      // Si on n'a pas la capacité de recevoir 
      if (getCapacity() < Source._nbCarac)
        {
          alloue(Source._nbCarac);
        }
      // On fait la copie
      _nbCarac = Source._nbCarac;
      strcpy(_CString, Source._CString);
    }
  // On a terminé, on se renvoie
  return *this;
}




// PsType & PsString::operator = (const PsType &Source)
// {
//   //cout << "PsString::operator = (const PsType &Source)" << endl;

//   // Le cast des PsType doit exister vers les PsString, d'où :
//   //operator = (*((PsString *)&Source));

//   // On utilise l'insertion du type vers le flux
//   strstream fluxTmp;
//   fluxTmp << Source;

//   // On extrait la PsString du flux
//   *this = fluxTmp.str();

//   // On l'affecte à notre chaîne
//   //*this = temp;

//   return *this;
// }

PsString & PsString::operator + (const PsType &Source)
{
   //cerr << "PsString::operator + (const PsType &Source)" << endl;
   
   //first insert the type in a string
#ifdef _USESSTREAM
   ostringstream fluxTmp;
   fluxTmp << Source ;
#else
   strstream fluxTmp;
   fluxTmp << Source <<'\0' ;
#endif
   
   //then constructuct a string corresponding to this
   string temp( getCString() ) ;
   
   // append the two stings and copy the result into this
   *this = temp + fluxTmp.str() ;
   
   //cerr << "PsString::operator + (const PsType &Source) done " << endl;
   return *this;
}

PsString & PsString::operator + (const string & source)
{   
   //then constructuct a string corresponding to this
   string temp( getCString() ) ;
   
   // append the two stings and copy the result into this
   *this = temp + source ;
   
   //cerr << "PsString::operator + (const PsType &Source) done " << endl;
   return *this;
}


// Gestion des flux ********************************************
void PsString::pack(PsOutgoingSynchronisationMessage & out) const 
{
   out<<_nbCarac<<_CString;
}

void PsString::unpack(PsIncomingSynchronisationMessage & in)
{
   in>> _nbCarac ;
   if (_tailleMem <= _nbCarac)
      {
         // Allocate the necessary memory
         alloue(_nbCarac);
      }
   in>>_CString ;
}

// Gestion des flux ********************************************
void PsString::pack(ostream & out) const 
{
   out<<_nbCarac<<" "<<_CString<<" ";
}

void PsString::unpack(istream & in)
{
   in>> _nbCarac ;
   if (_tailleMem <= _nbCarac)
      {
         // Allocate the necessary memory
         alloue(_nbCarac);
      }
   in.get (_CString, _nbCarac +1 ) ;
}

void PsString::extract (istream & in)
{
   //It is impossible to correctly extract an inserted stream because the inserted stream could have whitespaces
   string result ;
   in >> result ;
   alloue (result.size() + 1 ) ;
   strcpy (_CString, const_cast<char *>(result.c_str()) );
}

void PsString::insertInStream (ostream & out) const
{
  // insert the string
  out << _CString;
}

/************************************ operator << */
PsString & PsString::operator <<(separator f) 
{
   PsString espace(" ");
   *this=*this+espace;
   return *this;
}

PsString & sep(PsString & oChaine) 
{
   return (oChaine);
}

PsString & PsString::operator << (const char * f) {
   PsString tmp(f);
   *this<<tmp;
   return (*this);
}


PsString & PsString::operator << (const PsFlowable & f) {
#ifdef _USESSTREAM
   ostringstream myos ;
   myos << f ;
   *this = (*this) +  myos.str() ;
#else
   char tampon[LG_MAX_BUFFER];
   ostrstream myos(tampon,LG_MAX_BUFFER);
   myos<<f;
   int i = myos.pcount() ;
   PsString * chaineTemp;
   if (myos.fail()||(i>=LG_MAX_BUFFER)) {
      int tailleTampon=LG_MAX_BUFFER;
      char * biggerTampon;
      ostrstream * biggeros;
      do {
         tailleTampon=tailleTampon*2;
         biggerTampon=new char[tailleTampon];
         biggeros=new ostrstream(biggerTampon,tailleTampon);
         *biggeros<<f;
         i = biggeros->pcount() ;
      } 
      while(biggeros->fail()||(i>=tailleTampon));
      biggerTampon[i] = '\0' ;
      chaineTemp=new PsString(biggerTampon);
      delete [] biggerTampon;
      delete biggeros;
   }
   else {
     tampon[i]='\0' ;
     chaineTemp=new PsString(tampon);
   }
   *this=*this+*chaineTemp; 
   delete chaineTemp;
#endif
   return(*this);
}

PsString & PsString::operator >> (PsFlowable & f) {
   char * nouvelleChaine;
   int indiceDebutSuite;
#ifdef _USESSTREAM
   istringstream myis(_CString);
#else
   istrstream myis(_CString,_tailleMem);
#endif
   myis>>f;
   if(myis.fail()) {
#ifdef _DEBUGPVMMESS
      cerr<<"Impossible extraction"
          <<endl
          <<"The 2 main causes of this error are : you are trying to extract stuff from a string that wasn't inserted, but iether hand constructed in the string or not inserted at all"
          <<endl
      throw PsUserException ("PsString::operator>>: extraction impossible");
#endif    
   }
   indiceDebutSuite=myis.tellg();//si il y a une suite, elle va commencer à indiceDebutSuite
   //on supprime les séparateurs
   while(isspace(_CString[indiceDebutSuite])&&(_CString[indiceDebutSuite]!='\0')) {
      indiceDebutSuite++;
   };
   nouvelleChaine=new char[_tailleMem-indiceDebutSuite];
   strcpy(nouvelleChaine,_CString+indiceDebutSuite);
   if (_CString != NULL) delete [] _CString;
   _CString=nouvelleChaine;
   _nbCarac=strlen(_CString);
   _tailleMem=_tailleMem-indiceDebutSuite;
   return (*this);
}  


// Accesseurs en lecture ****************************************

int PsString::getStringLength() const
{
   //assert ( _nbCarac == _tailleMem - 1) ;
   return _nbCarac;
}

int PsString::getCapacity() const
{
  //assert ( _nbCarac == _tailleMem - 1) ;
   return _tailleMem-1;
}

const char* PsString::getCString() const
{
  //assert ( _nbCarac == _tailleMem - 1) ;
   return _CString;
}

// Opérateurs amis *********************************************

bool operator > (const PsString &Source1, const PsString &Source2)
{
  return (strcmp(Source1._CString, Source2._CString)> 0);
}

bool operator < (const PsString &Source1, const PsString &Source2)
{
   //      cout<<"operator < (const PsString , const PsString)"<<endl;
   //      cout<<"_"<<Source1._CString<<"_"<<Source2._CString<<"_"<<endl;
  return (strcmp(Source1._CString, Source2._CString)< 0);
}

bool operator >= (const PsString &Source1, const PsString &Source2)
{
  return (!(Source1 < Source2));
}

bool operator <= (const PsString &Source1, const PsString &Source2)
{
  return (!(Source1 > Source2));
}

bool operator != (const PsString &Source1, const PsString &Source2)
{
   //   cout<<"operator != (const PsString , const PsString)"<<endl;
   //   cout<<"_"<<Source1._CString<<"_"<<Source2._CString<<endl;
  return (strcmp(Source1._CString, Source2._CString));
}



bool operator == (const PsString &Source1, const PsString &Source2)
{
  return (!(Source1 != Source2));
}



PsString PsString::operator ++ (int i) {
   PsString retour (*this);
   ++(*this);
   return retour;
}

PsString & PsString::operator ++ () {
   char * nouvelleChaine;
   char zero('0');
   char neuf('9');
   if ((_nbCarac==0)||
       ((zero>_CString[_nbCarac-1])||(_CString[_nbCarac-1]>=neuf))) {
      //on a besoin d'écrire une case plus loin
      if(_tailleMem<=_nbCarac+1) {
         //on a potentiellement besoin de réallouer de la place 
         _tailleMem=_nbCarac+2;
         nouvelleChaine=new char[_tailleMem];
         if (!nouvelleChaine) {
            PsController::error("ERROR : Impossible d'allouer de la mémoire pour ++");
         }
         strcpy(nouvelleChaine,_CString);
         if (_CString!=NULL) {
            delete [] _CString;
         }
         _CString=nouvelleChaine;
      }
      if(_CString[_nbCarac-1]!=neuf) {
         _CString[_nbCarac]=zero;
         _CString[_nbCarac+1]='\0';
         _nbCarac++;
      }
      else {//le dernier caractère est 9
         int indicePremierPasNeuf=_nbCarac-1; 
         do {
            _CString[indicePremierPasNeuf]=zero;
            indicePremierPasNeuf--;
         }
         while (_CString[indicePremierPasNeuf]==neuf);
         if ( (_CString[indicePremierPasNeuf]>=zero)&&(_CString[indicePremierPasNeuf]<neuf))
            {
               _CString[indicePremierPasNeuf]++;
            }
         else {
            _CString[indicePremierPasNeuf+1]='1';
            _CString[_nbCarac]=zero;
            _CString[_nbCarac+1]='\0';
            _nbCarac++;
         } 
      }
   }
   else {
      _CString[_nbCarac-1]=_CString[_nbCarac-1]+1;
   }
   return *this;
}

PsString & PsString::operator -- () {

  char nouvelleChaine[20];
  char zero('0');
  char neuf('9');
  int nbNum ;
  int nombreTemps =0 ;
  int i,nb ;
  int puissance = 1;

  // cas chaine vide
  if (_nbCarac==0) 
    return *this ;

  // cas ou il n'y as pas de caractere numerique en fin de chaine  
  if ((zero>_CString[_nbCarac-1])||(_CString[_nbCarac-1]>neuf))
    return *this ;
    
  // bon cas
  if ((zero<_CString[_nbCarac-1])&&(_CString[_nbCarac-1]<=neuf))
    {
      // cas si un chiffre entre 1 et 9
      // +1, meme nombre de caractere
      _CString[_nbCarac-1]--;
      return *this ;
    }
  // on est dans le cas zero
  // conbien de caractere numerique ?
  // on sait que le dernier en est un
  nbNum = 1 ;
  while ( (zero<=_CString[_nbCarac-1-nbNum])&&(_CString[_nbCarac-1-nbNum]<=neuf) )
    nbNum++;
  
  if ((nbNum==1)&&(_CString[_nbCarac-1]==zero))
    {
      _nbCarac--;
      _CString[_nbCarac]='\0';
      return *this ; 
    }
  
  for(i=0;i<nbNum;i++)
    {
      nombreTemps =  (_CString[_nbCarac-1-i]-zero)*puissance + nombreTemps ;
      puissance = puissance *10 ;
    }
    
  nombreTemps--;
  nb=0;
  while (nombreTemps!=0)
    {
      // on rentre les chiffres a l'envers dans une chaine temporaire
      int val = nombreTemps % 10 ;
      nombreTemps = nombreTemps / 10 ;
      nouvelleChaine[nb] = zero + val ;
      nb++;
    }
    
  for(int j=1;j<=nb;j++)
    _CString[_nbCarac-nbNum+j-1] = nouvelleChaine[nb-j] ;
  
  //cout << "  _nbCarac : " <<  _nbCarac << endl ;
  //cout << "nb : " << nb << endl ; 
  //cout << "nbNum : " << nbNum << endl ;
  _nbCarac = _nbCarac - nbNum + nb ;
  _CString[_nbCarac] = '\0' ;
  
  return *this ;
}

// Méthode privée ************************************************

// Fonction privée d'allocation d'espace mémoire pour la chaîne stockée.
// Renvoie un pointeur char* ou interrompt le programme si l'allocation
// échoue.
void PsString::alloue(const int length)
{
   // Make sure length is correct
  //   assert (length >= 0 );

   // Si la chaîne était déjà allouée, on libère
   if (_CString!=NULL) 
      {
         delete [] _CString;    
         _CString = NULL ;
      }
   
   // On prévoit le caractère de fin de chaîne
   _tailleMem = length + 1;
   // On alloue la chaîne
#ifdef _MOME
   //si la chaine se trouve dans la mémoire partagée, il faut allouer le tampon dans la mémoire partagée
  PsnSharedMemoryManager * myMemory = PsMomeController::whichSharedMemoryManager(this);
  HeapStackTop newAllocationContext(myMemory) ;
#endif
  _CString = new char[_tailleMem];
  // Si l'allocation ne s'est pas bien passée
  if (!_CString)
    {
      PsController::error("ERROR : PsString::alloue() : Echec de l'allocation");
    }
  //cerr<<"Allocation d'une chaine dans la méméoire  à "<<(void *)_CString<<endl;
}

---