src/MEDLoader/MEDFileUtilities.cxx

   1 // Copyright (C) 2007-2020  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19 // Author : Anthony Geay (CEA/DEN)
  20
  21 #include "MEDFileUtilities.hxx"
  22 #include "MEDFileSafeCaller.txx"
  23 #include "MEDLoaderBase.hxx"
  24 #include "MEDLoader.hxx"
  25 #include "MEDFileBasis.hxx"
  26
  27 #include "InterpKernelAutoPtr.hxx"
  28
  29 #include <sstream>
  30 #include <fstream>
  31
  32 const char MEDCoupling::MEDFileWritableStandAlone::DFT_FILENAME_IN_MEM[]="DftFileNameInMemory";
  33
  34 med_access_mode MEDFileUtilities::TraduceWriteMode(int medloaderwritemode)
  35 {
  36   switch(medloaderwritemode)
  37   {
  38     case 2:
  39       return MED_ACC_CREAT;
  40     case 1:
  41       return MED_ACC_RDEXT;
  42     case 0:
  43       return MED_ACC_RDWR;
  44     default:
  45       throw INTERP_KERNEL::Exception("Invalid write mode specified ! must be 0(write with no question), 1(append) or 2(creation)");
  46   }
  47 }
  48
  49 const char *MEDFileUtilities::GetReadableMEDFieldType(med_field_type ft)
  50 {
  51   static const char medFloat64[]="MED_FLOAT64";
  52   static const char medInt32[]="MED_INT32";
  53   static const char medInt64[]="MED_INT64";
  54   switch(ft)
  55   {
  56     case MED_FLOAT64:
  57       return medFloat64;
  58     case MED_INT32:
  59       return medInt32;
  60     case MED_INT64:
  61       return medInt64;
  62     default:
  63       throw INTERP_KERNEL::Exception("Non supported field type ! Should be FLOAT64, INT32 or INT64 !");
  64   }
  65 }
  66
  67 void MEDFileUtilities::CheckMEDCode(int code, med_idt fid, const std::string& msg)
  68 {
  69   if(code<0)
  70     {
  71       std::ostringstream oss;
  72       oss << "MEDFile has returned an error code (" << code <<") : " << msg;
  73       throw INTERP_KERNEL::Exception(oss.str().c_str());
  74     }
  75 }
  76
  77 void MEDFileUtilities::CheckFileForRead(const std::string& fileName)
  78 {
  79   int status=MEDLoaderBase::getStatusOfFile(fileName);
  80   std::ostringstream oss;
  81   oss << " File : \"" << fileName << "\"";
  82   switch(status)
  83   {
  84     case MEDLoaderBase::DIR_LOCKED:
  85       {
  86         oss << " has been detected as unreadable : impossible to read anything !";
  87         throw INTERP_KERNEL::Exception(oss.str().c_str());
  88       }
  89     case MEDLoaderBase::NOT_EXIST:
  90       {
  91         oss << " has been detected as NOT EXISTING : impossible to read anything !";
  92         throw INTERP_KERNEL::Exception(oss.str().c_str());
  93       }
  94     case MEDLoaderBase::EXIST_WRONLY:
  95       {
  96         oss << " has been detected as WRITE ONLY : impossible to read anything !";
  97         throw INTERP_KERNEL::Exception(oss.str().c_str());
  98       }
  99   }
 100   AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
 101   if(fid<0)
 102     {
 103       oss << " has been detected as unreadable by MED file : impossible to read anything !";
 104       throw INTERP_KERNEL::Exception(oss.str().c_str());
 105     }
 106   oss << " has been detected readable but ";
 107   med_int major,minor,release;
 108   MEDfileNumVersionRd(fid,&major,&minor,&release);
 109   if(major<2 || (major==2 && minor<2))
 110     {
 111       oss << "version of MED file is < 2.2 : impossible to read anything !";
 112       throw INTERP_KERNEL::Exception(oss.str().c_str());
 113     }
 114 }
 115
 116 MEDFileUtilities::AutoFid::AutoFid(med_idt fid):_fid(fid)
 117 {
 118 }
 119
 120 MEDFileUtilities::AutoFid::~AutoFid()
 121 {
 122   MEDfileClose(_fid);
 123 }
 124
 125 MEDCoupling::MEDFileWritable::MEDFileWritable():_too_long_str(0),_zipconn_pol(2)
 126 {
 127 }
 128
 129 void MEDCoupling::MEDFileWritable::copyOptionsFrom(const MEDFileWritable& other) const
 130 {
 131   _too_long_str=other._too_long_str;
 132   _zipconn_pol=other._zipconn_pol;
 133 }
 134
 135 int MEDCoupling::MEDFileWritable::getTooLongStrPolicy() const
 136 {
 137   return _too_long_str;
 138 }
 139
 140 void MEDCoupling::MEDFileWritable::setTooLongStrPolicy(int newVal)
 141 {
 142   if(newVal!=2 && newVal!=1 && newVal!=0)
 143     throw INTERP_KERNEL::Exception("MEDFileWritable::setTooLongStrPolicy : invalid policy should be in 0,1 or 2 !");
 144   _too_long_str=newVal;
 145 }
 146
 147 int MEDCoupling::MEDFileWritable::getZipConnPolicy()
 148 {
 149   return _zipconn_pol;
 150 }
 151
 152 void MEDCoupling::MEDFileWritable::setZipConnPolicy(int newVal)
 153 {
 154   _zipconn_pol=newVal;
 155 }
 156
 157 std::string MEDCoupling::MEDFileWritable::FileNameFromFID(med_idt fid)
 158 {
 159   med_int lgth(MEDfileName(fid,0,0));
 160   if(lgth<=0)
 161     return std::string();
 162   INTERP_KERNEL::AutoPtr<char> tmp(new char[lgth+1]);
 163   if(MEDfileName(fid,tmp,lgth)<0)
 164     throw INTERP_KERNEL::Exception("MEDFileWritable::FileNameFromFID : Return code of MEDFile call \"MEDfileName\" is not >=0 as expected !");
 165   return std::string(tmp);
 166 }
 167
 168 MEDFileUtilities::AutoFid MEDCoupling::OpenMEDFileForRead(const std::string& fileName)
 169 {
 170   MEDFileUtilities::CheckFileForRead(fileName);
 171   return MEDFileUtilities::AutoFid(MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY));
 172 }
 173
 174 /*!
 175  * Writes \a this mesh into a MED file specified by its name.
 176  *  \param [in] fileName - the MED file name.
 177  *  \param [in] mode - the writing mode. For more on \a mode, see \ref AdvMEDLoaderBasics.
 178  * - 2 - erase; an existing file is removed.
 179  * - 1 - append; same data should not be present in an existing file.
 180  * - 0 - overwrite; same data present in an existing file is overwritten.
 181  *  \throw If the mesh name is not set.
 182  *  \throw If \a mode == 1 and the same data is present in an existing file.
 183  */
 184 void MEDCoupling::MEDFileWritableStandAlone::write(const std::string& fileName, int mode) const
 185 {
 186   med_access_mode medmod(MEDFileUtilities::TraduceWriteMode(mode));
 187   MEDFileUtilities::AutoFid fid(MEDfileOpen(fileName.c_str(),medmod));
 188   std::ostringstream oss; oss << "MEDFileWritableStandAlone : error on attempt to write in file : \"" << fileName << "\"";
 189   MEDFileUtilities::CheckMEDCode((int)fid,fid,oss.str());
 190   writeLL(fid);
 191 }
 192
 193 void MEDCoupling::MEDFileWritableStandAlone::write33(const std::string& fileName, int mode) const
 194 {
 195   this->writeXX(fileName,mode,3,3,1);
 196 }
 197
 198 void MEDCoupling::MEDFileWritableStandAlone::write30(const std::string& fileName, int mode) const
 199 {
 200   this->writeXX(fileName,mode,3,0,6);
 201 }
 202
 203 void MEDCoupling::MEDFileWritableStandAlone::writeXX(const std::string& fileName, int mode, med_int maj, med_int min, med_int rel) const
 204 {
 205 #if ( MED_NUM_MAJEUR>4 || ( MED_NUM_MAJEUR==4 && MED_NUM_MINEUR>=1 ) )
 206   med_access_mode medmod(MEDFileUtilities::TraduceWriteMode(mode));
 207   MEDFileUtilities::AutoFid fid(MEDfileVersionOpen(fileName.c_str(),medmod,maj,min,rel));
 208   writeLL(fid);
 209 #else
 210   std::ostringstream oss; oss << "MEDFileWritableStandAlone::write" << maj << min << " : the MED version used to compile medcoupling is " << MEDFileVersionStr() << " ! If you need this feature please use version >= 4.1.";
 211   throw INTERP_KERNEL::Exception(oss.str());
 212 #endif
 213 }
 214
 215 MEDCoupling::MCAuto<MEDCoupling::DataArrayByte> MEDCoupling::MEDFileWritableStandAlone::serialize() const
 216 {
 217   med_memfile memfile=MED_MEMFILE_INIT;
 218   memfile.app_image_ptr=0;
 219   memfile.app_image_size=0;
 220   //
 221   std::string dftFileName(GenerateUniqueDftFileNameInMem());
 222   {// very important to let this braces ! The AutoFid destructor must be called, to have a "clean" memfile.app_image_ptr pointer embedded in the returned object.
 223     MEDFileUtilities::AutoFid fid(MEDmemFileOpen(dftFileName.c_str(),&memfile,MED_FALSE,MED_ACC_CREAT));
 224     writeLL(fid);
 225   }
 226   //
 227   MEDCoupling::MCAuto<MEDCoupling::DataArrayByte> ret(MEDCoupling::DataArrayByte::New());
 228   ret->useArray(reinterpret_cast<char *>(memfile.app_image_ptr),true,DeallocType::C_DEALLOC,memfile.app_image_size,1);
 229   return ret;
 230 }
 231
 232 std::string MEDCoupling::MEDFileWritableStandAlone::GenerateUniqueDftFileNameInMem()
 233 {
 234   static int ii=0;
 235   std::ostringstream oss; oss << DFT_FILENAME_IN_MEM << "_" << ii++;
 236   return oss.str();
 237 }
 238
 239 MEDCoupling::MEDFileCapability::MEDFileCapability(med_idt fid)
 240 {
 241   MEDFILESAFECALLERRD0(MEDfileNumVersionRd,(fid,&_maj,&_min,&_rel));
 242 }