Back to index

salome-med  6.5.0
MEDMEM_Array.hxx
Go to the documentation of this file.
00001 // Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
00002 //
00003 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
00004 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
00005 //
00006 // This library is free software; you can redistribute it and/or
00007 // modify it under the terms of the GNU Lesser General Public
00008 // License as published by the Free Software Foundation; either
00009 // version 2.1 of the License.
00010 //
00011 // This library is distributed in the hope that it will be useful,
00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014 // Lesser General Public License for more details.
00015 //
00016 // You should have received a copy of the GNU Lesser General Public
00017 // License along with this library; if not, write to the Free Software
00018 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
00019 //
00020 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
00021 //
00022 
00023 #ifndef __MEDARRAY_H__
00024 #define __MEDARRAY_H__
00025 
00026 #include "MEDMEM_Exception.hxx"
00027 #include "MEDMEM_define.hxx"
00028 #include "MEDMEM_PointerOf.hxx"
00029 #include "MEDMEM_Utilities.hxx"
00030 
00062 namespace MEDMEM {
00063 template <class T> class MEDARRAY
00064 {
00065 private :
00066 
00068   int   _ldValues;
00070   int   _lengthValues;
00074   MED_EN::medModeSwitch _mode;
00076   PointerOf <T> _valuesFull;
00078   PointerOf <T> _valuesNo;
00080   PointerOf <T> _valuesDefault;
00082   PointerOf <T> _valuesOther;
00083 
00084 public :
00085 
00086   inline  MEDARRAY();
00087   inline ~MEDARRAY();
00088 
00089   MEDARRAY  (const int ld_values, const int length_values,
00090              const MED_EN::medModeSwitch mode=MED_EN::MED_FULL_INTERLACE);
00091   MEDARRAY  (T* values, const int ld_values,
00092              const int length_values, const MED_EN::medModeSwitch mode=MED_EN::MED_FULL_INTERLACE,bool shallowCopy=false, bool ownershipOfValues=false);
00093   MEDARRAY  (MEDARRAY const &m);
00094   MEDARRAY  (MEDARRAY const &m, bool copyOther);
00095   MEDARRAY & operator = (const MEDARRAY & m);
00096 
00097   MEDARRAY & shallowCopy(const MEDARRAY & m);
00098 
00099   inline int getLeadingValue() const;
00100   inline int getLengthValue()  const;
00101 
00102   const T * get        (const MED_EN::medModeSwitch mode) ;
00103   const T * getRow     (const int i) ;
00104   const T * getColumn  (const int j) ;
00105   const T   getIJ (const int i, const int j) const;
00106 //    T * const get        (const MED_EN::medModeSwitch mode) const;
00107 //    T * const getRow     (const int i) const;
00108 //    T * const getColumn  (const int j) const;
00109 //    T   const getIJ (const int i, const int j) const;
00110 
00111   inline MED_EN::medModeSwitch getMode() const;
00112 
00113   void set   (const MED_EN::medModeSwitch mode,const T* value);
00114   void setI  (const int i,             const T* value);
00115   void setJ  (const int j,             const T* value);
00116   void setIJ (const int i, const int j, const T  value);
00117 
00118   void calculateOther();
00119   bool isOtherCalculated() const {return (const T*)_valuesOther != NULL;}
00120   void clearOtherMode();
00121 };
00122 
00123 //-------------------------------------------------//
00124 //                                                 //
00125 //              IMPLEMENTED CODE                   //
00126 //                                                 //
00127 //-------------------------------------------------//
00128 
00129 
00130 template <class T> inline MEDARRAY<T>::MEDARRAY():
00131   _ldValues(0), _lengthValues(0), _mode(MED_EN::MED_FULL_INTERLACE),
00132   _valuesFull(), _valuesNo(),
00133   _valuesDefault(), _valuesOther()
00134 {
00135 }
00136 
00137 //                              ------------------
00138 
00139 template <class T> inline MEDARRAY<T>::~MEDARRAY()
00140 {
00141 }
00142 
00143 //                              ------------------
00144 
00154 template <class T> MEDARRAY<T>::MEDARRAY(const int ld_values,
00155                                          const int length_values,
00156                                          const MED_EN::medModeSwitch mode):
00157 
00158                                                 _ldValues(ld_values),
00159                                                 _lengthValues(length_values),
00160                                                 _mode(mode),
00161                                                 _valuesFull(), _valuesNo(),
00162                                                 _valuesDefault(),_valuesOther()
00163 {
00164   //  BEGIN_OF_MED("constructor MEDARRAY<T>::MEDARRAY(const int, const int, const medModeSwitch)");
00165 
00166   // if ld_values < 1 or length_values < 1
00167   // throws an exception
00168   // Pointers are setted to NULL
00169 
00170   if ((ld_values<1)|(length_values<1))
00171   {
00172         throw MEDEXCEPTION(LOCALIZED("MEDARRAY<T>::MEDARRAY(const int, const int, const medModeSwitch) : dimension < 1 !"));
00173   }
00174 
00175   if ( _mode == MED_EN::MED_FULL_INTERLACE)
00176   {
00177         _valuesFull.set(length_values*ld_values);
00178         _valuesDefault.set((T*) _valuesFull);
00179   }
00180   else
00181   {
00182         ASSERT_MED (_mode == MED_EN::MED_NO_INTERLACE);
00183         _valuesNo.set(length_values*ld_values);
00184         _valuesDefault.set((T*)_valuesNo);
00185   }
00186 
00187   ASSERT_MED( (T*)_valuesDefault != NULL);
00188 //   SCRUTE_MED((T*)_valuesDefault);
00189 //   SCRUTE_MED((T*)_valuesOther);
00190 //   SCRUTE_MED((T*)_valuesNo);
00191 //   SCRUTE_MED((T*)_valuesFull);
00192 
00193   //  END_OF_MED("constructor MEDARRAY<T>::MEDARRAY(const int, const int, const medModeSwitch ()");
00194 }
00195 
00196 //                              ------------------
00197 
00201 template <class T> MEDARRAY<T>::MEDARRAY( T*values,
00202                                           const int ld_values,
00203                                           const int length_values,
00204                                           const MED_EN::medModeSwitch mode,
00205                                           bool shallowCopy,
00206                                           bool ownershipOfValues):
00207                                                 _ldValues(ld_values),
00208                                                 _lengthValues(length_values),
00209                                                 _mode(mode),
00210                                                 _valuesFull(),_valuesNo(),
00211                                                 _valuesDefault(),_valuesOther()
00212 {
00213   //  BEGIN_OF_MED("constructor MEDARRAY<T>::MEDARRAY(T* values, const int, const int, const medModeSwitch)");
00214 
00215   // if ld_values < 1 or length_values < 1, we could not allocate
00216   // throws an exception
00217 
00218   if ( (ld_values<1) | (length_values<1) )
00219   {
00220            throw MEDEXCEPTION(LOCALIZED("MEDARRAY<T>::MEDARRAY(T* values, const int, const medModeSwitch) : dimension < 1 !"));
00221   }
00222   if ( _mode == MED_EN::MED_FULL_INTERLACE)
00223   {
00224         if(shallowCopy)
00225           {
00226             if(ownershipOfValues)
00227               {
00228                 _valuesFull.setShallowAndOwnership((const T*)values);
00229             }
00230             else
00231               {
00232                 _valuesFull.set((const T*)values);
00233               }
00234           }
00235         else
00236           {
00237             _valuesFull.set(_ldValues*length_values,values);
00238           }
00239         _valuesDefault.set((T*)_valuesFull);
00240   }
00241   else
00242   {
00243         ASSERT_MED (_mode == MED_EN::MED_NO_INTERLACE);
00244         if(shallowCopy)
00245         {
00246           if(ownershipOfValues)
00247             {
00248               _valuesNo.setShallowAndOwnership((const T*)values);
00249             }
00250           else
00251             {
00252               _valuesNo.set((const T*)values);
00253             }
00254         }
00255         else
00256           _valuesNo.set(_ldValues*length_values,values);
00257         _valuesDefault.set((T*)_valuesNo);
00258   }
00259   ASSERT_MED( (T*)_valuesDefault != NULL);
00260 //   SCRUTE_MED((T*)_valuesDefault);
00261 //   SCRUTE_MED((T*)_valuesOther);
00262 //   SCRUTE_MED((T*)_valuesNo);
00263 //   SCRUTE_MED((T*)_valuesFull);
00264 
00265   //  END_OF_MED("constructor MEDARRAY<T>::MEDARRAY(T* values, const int, const int, const medModeSwitch)");
00266 }
00267 
00268 //                              ------------------
00269 
00273 template <class T> MEDARRAY<T>::MEDARRAY(MEDARRAY<T> const & m ):
00274                                         _ldValues(m._ldValues),
00275                                         _lengthValues(m._lengthValues),
00276                                         _mode(m._mode),
00277                                         _valuesFull((const T*)m._valuesFull),
00278                                         _valuesNo((const T*)m._valuesNo),
00279                                         _valuesDefault((const T*)m._valuesDefault),
00280                                         _valuesOther((const T*)m._valuesOther)
00281 {
00282   //  BEGIN_OF_MED("constructor MEDARRAY<T>::MEDARRAY(MEDARRAY<T> const & m)");
00283   ASSERT_MED( (T*)_valuesDefault != NULL);
00284 //   SCRUTE_MED((T*)_valuesDefault);
00285 //   SCRUTE_MED((T*)_valuesOther);
00286 //   SCRUTE_MED((T*)_valuesNo);
00287 //   SCRUTE_MED((T*)_valuesFull);
00288   //  END_OF_MED("constructor MEDARRAY<T>::MEDARRAY(MEDARRAY<T> const & m)");
00289 }
00290 
00298 template <class T> MEDARRAY<T>::MEDARRAY(MEDARRAY<T> const & p,bool copyOther ):
00299                                         _ldValues(p._ldValues),
00300                                         _lengthValues(p._lengthValues),
00301                                         _mode(p._mode),
00302                                         _valuesFull(),
00303                                         _valuesNo(),
00304                                         _valuesDefault(),
00305                                         _valuesOther()
00306 {
00307   //  BEGIN_OF_MED("Constructeur deepCopy MEDARRAY<T>::MEDARRAY(MEDARRAY<T> const & m,bool copyOther");
00308 
00309   // PG : Non, s'il n'y a rien, on test et on ne copie rien, c'est tout !
00310 
00311 //    if ( copyOther==true && ((const T*)p._valuesOther==NULL))
00312 //      {
00313 //        throw MEDEXCEPTION("MEDARRAY MEDARRAY const &m,bool copyOther : No Other values defined and bool = true !");
00314 //      }
00315 
00316   if ( _mode == MED_EN::MED_FULL_INTERLACE)
00317     {
00318       _valuesFull.set(p._ldValues*p._lengthValues,(const T*)p._valuesFull);
00319       _valuesDefault.set((T*)_valuesFull);
00320       if (copyOther)
00321         if ((const T*)p._valuesNo != NULL)
00322           {
00323             _valuesNo.set(p._ldValues*p._lengthValues,(const T*)p._valuesNo);
00324             _valuesOther.set((T*)_valuesNo);
00325           }
00326     }
00327   else
00328     {
00329       ASSERT_MED (_mode == MED_EN::MED_NO_INTERLACE);
00330       _valuesNo.set(p._ldValues*p._lengthValues,(const T*)p._valuesNo);
00331       _valuesDefault.set((T*)_valuesNo);
00332       if (copyOther)
00333         if ((const T*)p._valuesFull != NULL)
00334           {
00335             _valuesFull.set(p._ldValues*p._lengthValues,(const T*)p._valuesFull);
00336             _valuesOther.set((T*)_valuesFull);
00337           }
00338     }
00339 }
00340 
00341 //                              ------------------
00342 
00345 template <class T> MEDARRAY<T> & MEDARRAY<T>::operator = (const MEDARRAY & m)
00346 {
00347 
00348   //  BEGIN_OF_MED("Operator = MEDARRAY<T>");
00349 
00350   _ldValues=m._ldValues;
00351   _lengthValues=m._lengthValues;
00352   _mode=m._mode;
00353 
00354   //  SCRUTE_MED(_mode);
00355 
00356   if ((const T*) m._valuesFull !=NULL)
00357     _valuesFull.set(_ldValues*_lengthValues,(const T*) m._valuesFull);
00358 
00359   if ((const T*) m._valuesNo !=NULL)
00360     _valuesNo.set(_ldValues*_lengthValues,(const T*) m._valuesNo);
00361 
00362   if (_mode == MED_EN::MED_FULL_INTERLACE) {
00363     //PN : pour enlever les warning compilateur
00364     //_valuesDefault.set((const T*) _valuesFull);
00365     //_valuesOther.set((const T*) _valuesNo);
00366     _valuesDefault.set((T*) _valuesFull);
00367     _valuesOther.set((T*) _valuesNo);
00368   } else {
00369     ASSERT_MED (_mode == MED_EN::MED_NO_INTERLACE);
00370     //PN : pour enlever les warning compilateur
00371     //_valuesDefault.set((const T*) _valuesNo);
00372     //_valuesOther.set((const T*) _valuesFull);
00373     _valuesDefault.set((T*) _valuesNo);
00374     _valuesOther.set((T*) _valuesFull);
00375   }
00376 
00377 //   SCRUTE_MED((T*)_valuesDefault);
00378 //   SCRUTE_MED((T*)_valuesOther);
00379 //   SCRUTE_MED((T*)_valuesNo);
00380 //   SCRUTE_MED((T*)_valuesFull);
00381 
00382   //  END_OF_MED("Operator = MEDARRAY<T>");
00383   return *this;
00384 }
00385 
00389 template <class T> MEDARRAY<T> & MEDARRAY<T>::shallowCopy(const MEDARRAY & m)
00390 {
00391   _ldValues=m._ldValues;
00392   _lengthValues=m._lengthValues;
00393   _mode=m._mode;
00394   if ((const T*) m._valuesFull !=NULL)
00395     _valuesFull.setShallowAndOwnership((const T*) m._valuesFull);
00396   if ((const T*) m._valuesNo !=NULL)
00397     _valuesNo.setShallowAndOwnership((const T*) m._valuesNo);
00398   if (_mode == MED_EN::MED_FULL_INTERLACE) {
00399     _valuesDefault.set((T*) _valuesFull);
00400     _valuesOther.set((T*) _valuesNo);
00401   } else {
00402     _valuesDefault.set((T*) _valuesNo);
00403     _valuesOther.set((T*) _valuesFull);
00404   }
00405   return *this;
00406 }
00407 
00408 //                              ------------------
00409 
00411 template <class T> inline int MEDARRAY<T>::getLeadingValue() const
00412 {
00413   return _ldValues;
00414 }
00415 
00416 //                              ------------------
00417 
00419 template <class T> inline int MEDARRAY<T>::getLengthValue() const
00420 {
00421   return _lengthValues;
00422 }
00423 
00424 //                              ------------------
00425 
00430 template <class T> const T* MEDARRAY<T>::get(const MED_EN::medModeSwitch mode)
00431 {
00432   //  BEGIN_OF_MED("MEDARRAY<T>::get(const medModeSwitch mode)");
00433   if ((T*)_valuesDefault == NULL)
00434   {
00435         throw MEDEXCEPTION("MEDARRAY::get(mode) : No values defined !");
00436   }
00437   if (mode == _mode)
00438   {
00439         //PN : pour enlever les warning compilateurs
00440         //return (const T*)_valuesDefault;
00441         return  (T*) _valuesDefault;
00442   }
00443   else
00444   {
00445         if ((T*)_valuesOther == NULL)
00446         {
00447                 calculateOther();
00448         }
00449         //PN : pour enlever les warning compilateurs
00450         //return (const T*)_valuesDefault;
00451         return  (T*) _valuesOther;
00452   }
00453 }
00454 
00455 //                              ------------------
00456 
00462 template <class T> const T* MEDARRAY<T>::getRow(const int i)
00463 {
00464   if ((T*)_valuesDefault == NULL)
00465   {
00466         throw MEDEXCEPTION("MEDARRAY::getRow(i) : No values defined !");
00467   }
00468   if (i<1)
00469   {
00470         throw MEDEXCEPTION("MEDARRAY::getRow(i) : argument i must be >= 1");
00471   }
00472   if (i>_lengthValues)
00473   {
00474         throw MEDEXCEPTION("MEDARRAY::getRow(i) : argument i must be <= _lengthValues");
00475   }
00476 
00477   if ((T*)_valuesFull == NULL)
00478   {
00479         calculateOther();
00480   }
00481   ASSERT_MED((T*)_valuesFull != NULL);
00482 
00483   // PN pour enlever les warning compilateurs
00484   //const T* ptr = (const T*)_valuesFull + (i-1)*_ldValues;
00485   const T* ptr =  (T*) _valuesFull + (i-1)*_ldValues;
00486 
00487   return ptr;
00488 }
00489 //                              ------------------
00490 
00497 template <class T> const T* MEDARRAY<T>::getColumn(const int j)
00498 {
00499   if ((T*)_valuesDefault == NULL)
00500   {
00501         throw MEDEXCEPTION("MEDARRAY::getColumn(j) : No values defined !");
00502   }
00503   if (j<1)
00504   {
00505         throw MEDEXCEPTION("MEDARRAY::getColumn(j) : argument j must be >= 1");
00506   }
00507   if (j>_ldValues)
00508   {
00509         throw MEDEXCEPTION("MEDARRAY::getColumn(j) : argument j must be <= _ldValues");
00510   }
00511 
00512   if ((T*)_valuesNo == NULL)
00513   {
00514         ASSERT_MED(((T*) _valuesDefault)==((T*) _valuesFull));
00515         calculateOther();
00516   }
00517   //PN pour enlever les warning compilateur
00518   //const T* ptr = (const T*)_valuesNo + (j-1)*_lengthValues;
00519   const T* ptr = ( T*)_valuesNo + (j-1)*_lengthValues;
00520 
00521   return ptr;
00522 }
00523 
00524 //                              ------------------
00525 
00528 template <class T> const T MEDARRAY<T>::getIJ(const int i,const  int j) const
00529 {
00530 
00531   if (i<1)
00532   {
00533         throw MEDEXCEPTION("MEDARRAY::getIJ(i,j) : argument i must be >= 1");
00534   }
00535   if (i>_lengthValues)
00536   {
00537         throw MEDEXCEPTION("MEDARRAY::getIJ(i,j) : argument i must be <= _lengthValues");
00538   }
00539   if (j<1)
00540   {
00541         throw MEDEXCEPTION("MEDARRAY::getIJ(i,j) : argument j must be >= 1");
00542   }
00543   if (j>_ldValues)
00544   {
00545         throw MEDEXCEPTION("MEDARRAY::getIJ(i,j) : argument j must be <= _ldValues");
00546   }
00547 
00548   if ( (const T*)_valuesDefault ==  NULL)
00549   {
00550         throw MEDEXCEPTION("MEDARRAY::getIJ(i,j) : No value in array !");
00551   }
00552 
00553   if (_mode == MED_EN::MED_FULL_INTERLACE)
00554   {
00555         return _valuesDefault[(i-1)*_ldValues+j-1];
00556   }
00557   else
00558   {
00559         return _valuesDefault[(j-1)*_lengthValues+i-1];
00560   }
00561 
00562 }
00563 
00564 //                              ------------------
00565 
00568 template <class T> inline MED_EN::medModeSwitch MEDARRAY<T>::getMode() const
00569 {
00570   return _mode;
00571 }
00572 
00573 //                              ------------------
00574 
00579 //  template <class T> void MEDARRAY<T>::set(const medModeSwitch mode, const T* value)
00580 //  {
00581 
00582 //    BEGIN_OF_MED("MEDARRAY<T>::set(mode,value)");
00583 
00584 //    _mode = mode;
00585 //    if ( _mode == MED_FULL_INTERLACE)
00586 //    {
00587 //      _valuesFull.set(value);
00588 //      _valuesDefault.set((T*)_valuesFull);
00589 //      _valuesNo.set(0);
00590 //    }
00591 //    else
00592 //    {
00593 //      ASSERT_MED (_mode == MED_NO_INTERLACE);
00594 //      _valuesNo.set(value);
00595 //      _valuesDefault.set((T*)_valuesNo);
00596 //      _valuesFull.set(0);
00597 //    }
00598 //    _valuesOther.set(0);
00599 //    END_OF_MED("MEDARRAY<T>::set(mode,i,value)");
00600 //  }
00601 
00602 // set with duplication because we don't know were value come and
00603 // MEDARRAY must have properties on it !!!!
00604 template <class T> void MEDARRAY<T>::set(const MED_EN::medModeSwitch mode, const T* value)
00605 {
00606   //  BEGIN_OF_MED("MEDARRAY<T>::set(mode,value)");
00607 
00608   _mode = mode;
00609   if ( _mode == MED_EN::MED_FULL_INTERLACE)
00610     {
00611       _valuesFull.set(_ldValues*_lengthValues,value);
00612       _valuesDefault.set((T*)_valuesFull);
00613       _valuesNo.set(0);
00614     }
00615   else
00616     {
00617       ASSERT_MED (_mode == MED_EN::MED_NO_INTERLACE);
00618       _valuesNo.set(_ldValues*_lengthValues,value);
00619       _valuesDefault.set((T*)_valuesNo);
00620       _valuesFull.set(0);
00621     }
00622   _valuesOther.set(0);
00623 
00624   //  END_OF_MED("MEDARRAY<T>::set(mode,i,value)");
00625 }
00626 
00631 template <class T> void MEDARRAY<T>::clearOtherMode()
00632 {
00633     if(isOtherCalculated())
00634     {
00635         if ( _mode == MED_EN::MED_FULL_INTERLACE)
00636             _valuesNo.set(0);
00637         else
00638             _valuesFull.set(0);
00639         _valuesOther.set(0);
00640     }
00641 }
00642 
00643 
00644 //                              ------------------
00645 
00649 template <class T> void MEDARRAY<T>::setI(const int i, const T* value)
00650 {
00651   //  BEGIN_OF_MED("MEDARRAY<T>::setI(i,value)");
00652 
00653   if ((T*)_valuesDefault == NULL)
00654   {
00655         throw MEDEXCEPTION("MEDARRAY::setI(i,value) : No values defined !");
00656   }
00657   if (i<=0)
00658   {
00659       throw MEDEXCEPTION("MEDARRAY::setI(i,value) : argument i must be > 0");
00660   }
00661   if ( i > _lengthValues)
00662   {
00663      throw MEDEXCEPTION("MEDARRAY::setI(i,value) : argument i must be <= _lenghtValues");
00664   }
00665 
00666   if ((T*)_valuesFull != NULL)
00667   {
00668    for (int k = 0;k<_ldValues;k++)
00669    {
00670                 _valuesFull[k+_ldValues*(i-1)] = value[k];
00671    }
00672   }
00673 
00674   if ((T*)_valuesNo != NULL)
00675   {
00676    for (int k = 0;k<_ldValues;k++)
00677    {
00678                 _valuesNo[k*_lengthValues +(i-1)] = value[k];
00679    }
00680   }
00681 
00682   //  END_OF_MED("MEDARRAY::setI(i,value)");
00683 }
00684 //                              ------------------
00685 
00689 template <class T> void MEDARRAY<T>::setJ(const int j, const T* value)
00690 {
00691   //  BEGIN_OF_MED("MEDARRAY::setJ(j,value)");
00692   if (( T*)_valuesDefault == NULL)
00693   {
00694         throw MEDEXCEPTION("MEDARRAY::setJ(j) : No values defined !");
00695   }
00696   if (j<1)
00697   {
00698         throw MEDEXCEPTION("MEDARRAY::setJ(j) : argument j must be >= 1");
00699   }
00700   if (j>_ldValues)
00701   {
00702         throw MEDEXCEPTION("MEDARRAY::setJ(j) : argument j must be <= _ldValues");
00703   }
00704   if ((T*)_valuesFull != NULL)
00705   {
00706    for (int k = 0;k<_lengthValues;k++)
00707    {
00708                 _valuesFull[k*_ldValues+(j-1)] = value[k];
00709    }
00710   }
00711 
00712   if ((T*)_valuesNo != NULL)
00713   {
00714    for (int k = 0;k<_lengthValues;k++)
00715    {
00716                 _valuesNo[k+_lengthValues*(j-1)] = value[k];
00717    }
00718   }
00719   //  END_OF_MED("MEDARRAY::setJ(j,value)");
00720 }
00721 
00722 //                              ------------------
00723 
00728 template <class T> void MEDARRAY<T>::setIJ(const int i, const int j, const T value)
00729 {
00730   // 1<=i<=_lengthValues and 1<=j<=_ldValues
00731 
00732   if (i<1)
00733     throw MEDEXCEPTION("MEDARRAY::setIJ(i,j,value) : argument i must be >= 1");
00734   if (i>_lengthValues)
00735     throw MEDEXCEPTION("MEDARRAY::setIJ(i,j,value) : argument i must be <= _lengthValues");
00736 
00737   if (j<1)
00738     throw MEDEXCEPTION("MEDARRAY::setIJ(i,j,value) : argument j must be >= 1");
00739   if (j>_ldValues)
00740     throw MEDEXCEPTION("MEDARRAY::setIJ(i,j,value) : argument j must be <= _ldValues");
00741 
00742   if ((T*)_valuesDefault == NULL)
00743   {
00744     throw MEDEXCEPTION("MEDARRAY::setIJ(i,j,value) : No value in array !");
00745   }
00746 
00747   if ((T*)_valuesFull != NULL)
00748   {
00749         _valuesFull[j-1+_ldValues*(i-1)] = value;
00750   }
00751   if ((T*)_valuesNo != NULL)
00752   {
00753         _valuesNo[(j-1)*_lengthValues+i-1] = value;
00754   }
00755 }
00756 
00760 template <class T> void MEDARRAY<T>::calculateOther()
00761 {
00762   //  BEGIN_OF_MED("MEDARRAY<T>::calculateOther()");
00763   if ((T*)_valuesDefault == NULL)
00764   {
00765         throw MEDEXCEPTION("MEDARRAY::calculateOther() : No values defined !");
00766   }
00767 
00768   if ((T*)_valuesOther == NULL)
00769   {
00770         _valuesOther.set(_ldValues*_lengthValues);
00771   }
00772   if (_mode == MED_EN::MED_NO_INTERLACE)
00773   {
00774         _valuesFull.set((T*)_valuesOther);
00775   }
00776   else
00777   {
00778         ASSERT_MED( _mode==MED_EN::MED_FULL_INTERLACE);
00779         _valuesNo.set((T*)_valuesOther);
00780   }
00781 
00782   for (int i=0; i<_lengthValues;i++)
00783   {
00784         for (int j=0; j<_ldValues; j++)
00785         {
00786                 if (_mode == MED_EN::MED_NO_INTERLACE)
00787                 {
00788                         _valuesFull[i*_ldValues+j] = _valuesNo[j*_lengthValues+i];
00789                 }
00790                 else
00791                 {
00792                         _valuesNo[j*_lengthValues+i]=_valuesFull[i*_ldValues+j];
00793                 }
00794         }
00795   }
00796   //  END_OF_MED("MEDARRAY<T>::calculateOther()");
00797 }
00798 
00799 } //End of namespace MEDMEM
00800 
00801 # endif         /* # ifndef __MEDARRAY_H__ */