WIP

diff --git a/src/MEDLoader/MEDFileField.cxx b/src/MEDLoader/MEDFileField.cxx
index 4cfee0c64d2d9bb8f0a4a6d673fb41211b99ec96..4ddc793ecde7a829ec997d6c67f5dbb40728d985 100644 (file)
--- a/src/MEDLoader/MEDFileField.cxx
+++ b/src/MEDLoader/MEDFileField.cxx
@@ -273,7 +273,7 @@ try:MEDFileFieldGlobsReal(fid)
           }
         case MED_INT32:
           {
-            _fields[i]=MEDFileIntFieldMultiTSWithoutSDA::New(fid,fieldName,meshName,typcha,infos,nbOfStep,dtunit,loadAll,ms,entities);
+            _fields[i]=MEDFileInt32FieldMultiTSWithoutSDA::New(fid,fieldName,meshName,typcha,infos,nbOfStep,dtunit,loadAll,ms,entities);
             break;
           }
         case MED_FLOAT32:
@@ -285,7 +285,7 @@ try:MEDFileFieldGlobsReal(fid)
           {
             if(sizeof(med_int)==sizeof(int))
               {
-                _fields[i]=MEDFileIntFieldMultiTSWithoutSDA::New(fid,fieldName,meshName,typcha,infos,nbOfStep,dtunit,loadAll,ms,entities);
+                _fields[i]=MEDFileInt32FieldMultiTSWithoutSDA::New(fid,fieldName,meshName,typcha,infos,nbOfStep,dtunit,loadAll,ms,entities);
                 break;
               }
           }
@@ -848,12 +848,12 @@ MEDFileAnyTypeFieldMultiTS *MEDFileFields::getFieldAtPos(int i) const
     return 0;
   MCAuto<MEDFileAnyTypeFieldMultiTS> ret;
   const MEDFileFieldMultiTSWithoutSDA *fmtsC(dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(fmts));
-  const MEDFileIntFieldMultiTSWithoutSDA *fmtsC2(dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(fmts));
+  const MEDFileInt32FieldMultiTSWithoutSDA *fmtsC2(dynamic_cast<const MEDFileInt32FieldMultiTSWithoutSDA *>(fmts));
   const MEDFileFloatFieldMultiTSWithoutSDA *fmtsC3(dynamic_cast<const MEDFileFloatFieldMultiTSWithoutSDA *>(fmts));
   if(fmtsC)
     ret=MEDFileFieldMultiTS::New(*fmtsC,false);
   else if(fmtsC2)
-    ret=MEDFileIntFieldMultiTS::New(*fmtsC2,false);
+    ret=MEDFileInt32FieldMultiTS::New(*fmtsC2,false);
   else if(fmtsC3)
     ret=MEDFileFloatFieldMultiTS::New(*fmtsC3,false);
   else

diff --git a/src/MEDLoader/MEDFileFieldMultiTS.cxx b/src/MEDLoader/MEDFileFieldMultiTS.cxx
index b6807f27fb15b2a6f882259402186030ebfd6210..b63823b1d037baefe3501c446e0854f3c7eadfab 100644 (file)
--- a/src/MEDLoader/MEDFileFieldMultiTS.cxx
+++ b/src/MEDLoader/MEDFileFieldMultiTS.cxx
@@ -1080,7 +1080,7 @@ void MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldNoProfileSBT(const MEDCoup
 void MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldProfile(const MEDCouplingFieldDouble *field, const DataArray *arr, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayIdType *profile, MEDFileFieldGlobsReal& glob, bool smartPflKiller)
 {
   if(!field)
-    throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::appendFieldNoProfileSBT : input field is NULL !");
+    throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldNoProfileSBT : input field is NULL !");
   if(!_time_steps.empty())
     checkCoherencyOfTinyInfo(field,arr);
   MCAuto<MEDFileAnyTypeField1TSWithoutSDA> obj(createNew1TSWithoutSDAEmptyInstance());
@@ -1128,9 +1128,9 @@ std::vector< std::vector<DataArrayDouble *> > MEDFileFieldMultiTSWithoutSDA::get
   return myF1TSC->getFieldSplitedByType2(mname,types,typesF,pfls,locs);
 }
 
-MEDFileIntFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::convertToInt() const
+MEDFileInt32FieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::convertToInt() const
 {
-  MCAuto<MEDFileIntFieldMultiTSWithoutSDA> ret(new MEDFileIntFieldMultiTSWithoutSDA);
+  MCAuto<MEDFileInt32FieldMultiTSWithoutSDA> ret(new MEDFileInt32FieldMultiTSWithoutSDA);
   ret->MEDFileAnyTypeFieldMultiTSWithoutSDA::operator =(*this);
   int i=0;
   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
@@ -1183,7 +1183,7 @@ MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::BuildContentFr
       }
     case MED_INT32:
       {
-        ret=new MEDFileIntFieldMultiTSWithoutSDA(fid,i,loadAll,ms,entities);
+        ret=new MEDFileInt32FieldMultiTSWithoutSDA(fid,i,loadAll,ms,entities);
         break;
       }
     case MED_FLOAT32:
@@ -1195,7 +1195,7 @@ MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::BuildContentFr
       {
         if(sizeof(med_int)==sizeof(int))
           {
-            ret=new MEDFileIntFieldMultiTSWithoutSDA(fid,i,loadAll,ms,entities);
+            ret=new MEDFileInt32FieldMultiTSWithoutSDA(fid,i,loadAll,ms,entities);
             break;
           }
       }
@@ -1227,7 +1227,7 @@ MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::BuildContentFr
       }
     case MED_INT32:
       {
-        ret=new MEDFileIntFieldMultiTSWithoutSDA(fid,0,loadAll,ms,0);
+        ret=new MEDFileInt32FieldMultiTSWithoutSDA(fid,0,loadAll,ms,0);
         break;
       }
     case MED_FLOAT32:
@@ -1239,7 +1239,7 @@ MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::BuildContentFr
       {
         if(sizeof(med_int)==sizeof(int))
           {
-            ret=new MEDFileIntFieldMultiTSWithoutSDA(fid,0,loadAll,ms,0);
+            ret=new MEDFileInt32FieldMultiTSWithoutSDA(fid,0,loadAll,ms,0);
             break;
           }
       }
@@ -1264,9 +1264,9 @@ MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromCont
       ret->_content=c;  c->incrRef();
       return ret.retn();
     }
-  if(dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(c))
+  if(dynamic_cast<const MEDFileInt32FieldMultiTSWithoutSDA *>(c))
     {
-      MCAuto<MEDFileIntFieldMultiTS> ret(MEDFileIntFieldMultiTS::New());
+      MCAuto<MEDFileInt32FieldMultiTS> ret(MEDFileInt32FieldMultiTS::New());
       ret->_content=c;  c->incrRef();
       return ret.retn();
     }
@@ -1301,10 +1301,10 @@ catch(INTERP_KERNEL::Exception& e)
 //= MEDFileAnyTypeFieldMultiTS
 
 /*!
- * Returns a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS holding data of the first field
+ * Returns a new instance of MEDFileFieldMultiTS or MEDFileInt32FieldMultiTS holding data of the first field
  * that has been read from a specified MED file.
  *  \param [in] fileName - the name of the MED file to read.
- *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS. The caller
+ *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS or MEDFileInt32FieldMultiTS. The caller
  *          is to delete this field using decrRef() as it is no more needed.
  *  \throw If reading the file fails.
  */
@@ -1323,11 +1323,11 @@ MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(med_idt fid, bool lo
 }
 
 /*!
- * Returns a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS holding data of a given field
+ * Returns a new instance of MEDFileFieldMultiTS or MEDFileInt32FieldMultiTS holding data of a given field
  * that has been read from a specified MED file.
  *  \param [in] fileName - the name of the MED file to read.
  *  \param [in] fieldName - the name of the field to read.
- *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS. The caller
+ *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS or MEDFileInt32FieldMultiTS. The caller
  *          is to delete this field using decrRef() as it is no more needed.
  *  \throw If reading the file fails.
  *  \throw If there is no field named \a fieldName in the file.
@@ -2041,7 +2041,7 @@ MCAuto<MEDFileAnyTypeFieldMultiTS> MEDFileAnyTypeFieldMultiTS::Aggregate(const s
     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::Aggregate : input vector is empty !");
   std::size_t sz(fmtss.size());
   std::vector<const MEDFileFieldMultiTS *> fmtss1;
-  std::vector<const MEDFileIntFieldMultiTS *> fmtss2;
+  std::vector<const MEDFileInt32FieldMultiTS *> fmtss2;
   for(std::vector<const MEDFileAnyTypeFieldMultiTS *>::const_iterator it=fmtss.begin();it!=fmtss.end();it++)
     {
       if(!(*it))
@@ -2052,7 +2052,7 @@ MCAuto<MEDFileAnyTypeFieldMultiTS> MEDFileAnyTypeFieldMultiTS::Aggregate(const s
           fmtss1.push_back(elt1);
           continue;
         }
-      const MEDFileIntFieldMultiTS *elt2(dynamic_cast<const MEDFileIntFieldMultiTS *>(*it));
+      const MEDFileInt32FieldMultiTS *elt2(dynamic_cast<const MEDFileInt32FieldMultiTS *>(*it));
       if(elt2)
         {
           fmtss2.push_back(elt2);
@@ -2087,22 +2087,22 @@ MEDFileAnyTypeFieldMultiTS *MEDFileFieldMultiTS::shallowCpy() const
  *
  * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
  *                            By default (true) the globals are deeply copied.
- * \return MEDFileIntFieldMultiTS * - a new object that is the result of the conversion of \a this to int32 field.
+ * \return MEDFileInt32FieldMultiTS * - a new object that is the result of the conversion of \a this to int32 field.
  */
-MEDFileIntFieldMultiTS *MEDFileFieldMultiTS::convertToInt(bool isDeepCpyGlobs) const
+MEDFileInt32FieldMultiTS *MEDFileFieldMultiTS::convertToInt(bool isDeepCpyGlobs) const
 {
-  MCAuto<MEDFileIntFieldMultiTS> ret;
+  MCAuto<MEDFileInt32FieldMultiTS> ret;
   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
   if(content)
     {
       const MEDFileFieldMultiTSWithoutSDA *contc=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(content);
       if(!contc)
         throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::convertToInt : the content inside this is not FLOAT64 ! This is incoherent !");
-      MCAuto<MEDFileIntFieldMultiTSWithoutSDA> newc(contc->convertToInt());
-      ret=static_cast<MEDFileIntFieldMultiTS *>(MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent((MEDFileIntFieldMultiTSWithoutSDA *)newc));
+      MCAuto<MEDFileInt32FieldMultiTSWithoutSDA> newc(contc->convertToInt());
+      ret=static_cast<MEDFileInt32FieldMultiTS *>(MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent((MEDFileInt32FieldMultiTSWithoutSDA *)newc));
     }
   else
-    ret=MEDFileIntFieldMultiTS::New();
+    ret=MEDFileInt32FieldMultiTS::New();
   if(isDeepCpyGlobs)
     ret->deepCpyGlobs(*this);
   else
@@ -2162,4 +2162,4 @@ MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTSIterator::nextt()
     return 0;
 }
 
-//= MEDFileIntFieldMultiTS
+//= MEDFileInt32FieldMultiTS

diff --git a/src/MEDLoader/MEDFileFieldMultiTS.hxx b/src/MEDLoader/MEDFileFieldMultiTS.hxx
index c565a3e0ac3f45ed8611e910e1db11281bdc52cc..508aeb7cc839a521892a9ea05e3ce0447a90afff 100644 (file)
--- a/src/MEDLoader/MEDFileFieldMultiTS.hxx
+++ b/src/MEDLoader/MEDFileFieldMultiTS.hxx
@@ -18,8 +18,7 @@
 //
 // Author : Anthony Geay (EDF R&D)
 
-#ifndef __MEDFILEFIELDMULTITS_HXX__
-#define __MEDFILEFIELDMULTITS_HXX__
+#pragma once
 
 #include "MEDLoaderDefines.hxx"
 #include "MEDFileField1TS.hxx"
@@ -119,7 +118,7 @@ namespace MEDCoupling
     std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > _time_steps;
   };
 
-  class MEDFileIntFieldMultiTSWithoutSDA;
+  class MEDFileInt32FieldMultiTSWithoutSDA;
 
   template<class T>
   class MEDFileTemplateFieldMultiTSWithoutSDA : public MEDFileAnyTypeFieldMultiTSWithoutSDA
@@ -145,7 +144,7 @@ namespace MEDCoupling
   public:
     MEDLOADER_EXPORT MEDFileFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities):MEDFileTemplateFieldMultiTSWithoutSDA<double>(fid,fieldId,loadAll,ms,entities) { }
     MEDLOADER_EXPORT std::vector< std::vector<DataArrayDouble *> > getFieldSplitedByType2(int iteration, int order, const std::string& mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const;
-    MEDLOADER_EXPORT MEDFileIntFieldMultiTSWithoutSDA *convertToInt() const;
+    MEDLOADER_EXPORT MEDFileInt32FieldMultiTSWithoutSDA *convertToInt() const;
     MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTSWithoutSDA *shallowCpy() const { return new MEDFileFieldMultiTSWithoutSDA(*this); }
     MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileFieldMultiTSWithoutSDA"); }
   protected:
@@ -168,19 +167,34 @@ namespace MEDCoupling
     MEDFileNDTemplateFieldMultiTSWithoutSDA(med_idt fid, const std::string& fieldName, const std::string& meshName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities):MEDFileTemplateFieldMultiTSWithoutSDA<T>(fid,fieldName,meshName,fieldTyp,infos,nbOfStep,dtunit,loadAll,ms,entities) { }
   };
 
-  class MEDFileIntFieldMultiTSWithoutSDA : public MEDFileNDTemplateFieldMultiTSWithoutSDA<int>
+  class MEDFileInt32FieldMultiTSWithoutSDA : public MEDFileNDTemplateFieldMultiTSWithoutSDA<Int32>
   {
-    friend class MEDFileTemplateFieldMultiTSWithoutSDA<int>;
+    friend class MEDFileTemplateFieldMultiTSWithoutSDA<Int32>;
   public:
-    MEDLOADER_EXPORT MEDFileIntFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities):MEDFileNDTemplateFieldMultiTSWithoutSDA<int>(fid,fieldId,loadAll,ms,entities) { }
-    MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTSWithoutSDA *shallowCpy() const { return new MEDFileIntFieldMultiTSWithoutSDA(*this); }
-    MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileIntFieldMultiTSWithoutSDA"); }
+    MEDLOADER_EXPORT MEDFileInt32FieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities):MEDFileNDTemplateFieldMultiTSWithoutSDA<Int32>(fid,fieldId,loadAll,ms,entities) { }
+    MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTSWithoutSDA *shallowCpy() const { return new MEDFileInt32FieldMultiTSWithoutSDA(*this); }
+    MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileInt32FieldMultiTSWithoutSDA"); }
   protected:
-    MEDFileIntFieldMultiTSWithoutSDA(const std::string& fieldName, const std::string& meshName):MEDFileNDTemplateFieldMultiTSWithoutSDA<int>(fieldName,meshName) { }
-    MEDFileIntFieldMultiTSWithoutSDA(med_idt fid, const std::string& fieldName, const std::string& meshName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities):MEDFileNDTemplateFieldMultiTSWithoutSDA<int>(fid,fieldName,meshName,fieldTyp,infos,nbOfStep,dtunit,loadAll,ms,entities) { }
+    MEDFileInt32FieldMultiTSWithoutSDA(const std::string& fieldName, const std::string& meshName):MEDFileNDTemplateFieldMultiTSWithoutSDA<Int32>(fieldName,meshName) { }
+    MEDFileInt32FieldMultiTSWithoutSDA(med_idt fid, const std::string& fieldName, const std::string& meshName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities):MEDFileNDTemplateFieldMultiTSWithoutSDA<Int32>(fid,fieldName,meshName,fieldTyp,infos,nbOfStep,dtunit,loadAll,ms,entities) { }
     med_field_type getMEDFileFieldType() const { return MED_INT32; }
   public:
-    MEDLOADER_EXPORT MEDFileIntFieldMultiTSWithoutSDA() { }
+    MEDLOADER_EXPORT MEDFileInt32FieldMultiTSWithoutSDA() { }
+  };
+
+  class MEDFileInt64FieldMultiTSWithoutSDA : public MEDFileNDTemplateFieldMultiTSWithoutSDA<Int64>
+  {
+    friend class MEDFileTemplateFieldMultiTSWithoutSDA<Int64>;
+  public:
+    MEDLOADER_EXPORT MEDFileInt64FieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities):MEDFileNDTemplateFieldMultiTSWithoutSDA<Int64>(fid,fieldId,loadAll,ms,entities) { }
+    MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTSWithoutSDA *shallowCpy() const { return new MEDFileInt64FieldMultiTSWithoutSDA(*this); }
+    MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileInt64FieldMultiTSWithoutSDA"); }
+  protected:
+    MEDFileInt64FieldMultiTSWithoutSDA(const std::string& fieldName, const std::string& meshName):MEDFileNDTemplateFieldMultiTSWithoutSDA<Int64>(fieldName,meshName) { }
+    MEDFileInt64FieldMultiTSWithoutSDA(med_idt fid, const std::string& fieldName, const std::string& meshName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities):MEDFileNDTemplateFieldMultiTSWithoutSDA<Int64>(fid,fieldName,meshName,fieldTyp,infos,nbOfStep,dtunit,loadAll,ms,entities) { }
+    med_field_type getMEDFileFieldType() const { return MED_INT64; }
+  public:
+    MEDLOADER_EXPORT MEDFileInt64FieldMultiTSWithoutSDA() { }
   };
 
   class MEDFileFloatFieldMultiTSWithoutSDA : public MEDFileNDTemplateFieldMultiTSWithoutSDA<float>
@@ -347,7 +361,7 @@ namespace MEDCoupling
     friend class MEDFileTemplateFieldMultiTS<double>;
   public:
     MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTS *shallowCpy() const;
-    MEDLOADER_EXPORT MEDFileIntFieldMultiTS *convertToInt(bool isDeepCpyGlobs=true) const;
+    MEDLOADER_EXPORT MEDFileInt32FieldMultiTS *convertToInt(bool isDeepCpyGlobs=true) const;
     MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileFieldMultiTS"); }
     //
     MEDLOADER_EXPORT std::vector< std::vector<DataArrayDouble *> > getFieldSplitedByType2(int iteration, int order, const std::string& mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const;
@@ -377,19 +391,37 @@ namespace MEDCoupling
   /*!
    * User class.
    */
-  class MEDFileIntFieldMultiTS : public MEDFileNDTemplateFieldMultiTS<int>
+  class MEDFileInt32FieldMultiTS : public MEDFileNDTemplateFieldMultiTS<Int32>
   {
-    friend class MEDFileTemplateFieldMultiTS<int>;
+    friend class MEDFileTemplateFieldMultiTS<Int32>;
   public:
-    MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTS *shallowCpy() const { return new MEDFileIntFieldMultiTS(*this); }
-    MEDLOADER_EXPORT MEDFileIntFieldMultiTS *buildNewEmpty() const { return buildNewEmptyImpl(); }
-    MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileIntFieldMultiTS"); }
+    MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTS *shallowCpy() const { return new MEDFileInt32FieldMultiTS(*this); }
+    MEDLOADER_EXPORT MEDFileInt32FieldMultiTS *buildNewEmpty() const { return buildNewEmptyImpl(); }
+    MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileInt32FieldMultiTS"); }
   private:
-    ~MEDFileIntFieldMultiTS() { }
-    MEDFileIntFieldMultiTS() { }
-    MEDFileIntFieldMultiTS(const MEDFileIntFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileNDTemplateFieldMultiTS<int>(other,shallowCopyOfContent) { }
-    MEDFileIntFieldMultiTS(med_idt fid, bool loadAll, const MEDFileMeshes *ms):MEDFileNDTemplateFieldMultiTS<int>(fid,loadAll,ms) { }
-    MEDFileIntFieldMultiTS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities=0):MEDFileNDTemplateFieldMultiTS<int>(fid,fieldName,loadAll,ms,entities) { }
+    ~MEDFileInt32FieldMultiTS() { }
+    MEDFileInt32FieldMultiTS() { }
+    MEDFileInt32FieldMultiTS(const MEDFileInt32FieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileNDTemplateFieldMultiTS<Int32>(other,shallowCopyOfContent) { }
+    MEDFileInt32FieldMultiTS(med_idt fid, bool loadAll, const MEDFileMeshes *ms):MEDFileNDTemplateFieldMultiTS<Int32>(fid,loadAll,ms) { }
+    MEDFileInt32FieldMultiTS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities=0):MEDFileNDTemplateFieldMultiTS<Int32>(fid,fieldName,loadAll,ms,entities) { }
+  };
+
+  /*!
+   * User class.
+   */
+  class MEDFileInt64FieldMultiTS : public MEDFileNDTemplateFieldMultiTS<Int64>
+  {
+    friend class MEDFileTemplateFieldMultiTS<Int64>;
+  public:
+    MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTS *shallowCpy() const { return new MEDFileInt64FieldMultiTS(*this); }
+    MEDLOADER_EXPORT MEDFileInt64FieldMultiTS *buildNewEmpty() const { return buildNewEmptyImpl(); }
+    MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileInt64FieldMultiTS"); }
+  private:
+    ~MEDFileInt64FieldMultiTS() { }
+    MEDFileInt64FieldMultiTS() { }
+    MEDFileInt64FieldMultiTS(const MEDFileInt64FieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileNDTemplateFieldMultiTS<Int64>(other,shallowCopyOfContent) { }
+    MEDFileInt64FieldMultiTS(med_idt fid, bool loadAll, const MEDFileMeshes *ms):MEDFileNDTemplateFieldMultiTS<Int64>(fid,loadAll,ms) { }
+    MEDFileInt64FieldMultiTS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities=0):MEDFileNDTemplateFieldMultiTS<Int64>(fid,fieldName,loadAll,ms,entities) { }
   };
 
   /*!
@@ -422,5 +454,3 @@ namespace MEDCoupling
     int _nb_iter;
   };
 }
-
-#endif

diff --git a/src/MEDLoader/MEDLoaderTraits.hxx b/src/MEDLoader/MEDLoaderTraits.hxx
index d0e0551b91931ab77e5ea5490436373f699a469e..336517e73377c415264f8d4a2cfb0a7a5746167d 100644 (file)
--- a/src/MEDLoader/MEDLoaderTraits.hxx
+++ b/src/MEDLoader/MEDLoaderTraits.hxx
@@ -33,7 +33,8 @@ namespace MEDCoupling
 
   class MEDFileFieldMultiTS;
   class MEDFileField1TS;
-  class MEDFileIntFieldMultiTS;
+  class MEDFileInt32FieldMultiTS;
+  class MEDFileInt64FieldMultiTS;
   class MEDFileInt32Field1TS;
   class MEDFileInt64Field1TS;
   class MEDFileFloatFieldMultiTS;
@@ -43,7 +44,8 @@ namespace MEDCoupling
   class MEDFileInt64Field1TSWithoutSDA;
   class MEDFileFloatField1TSWithoutSDA;
   class MEDFileFieldMultiTSWithoutSDA;
-  class MEDFileIntFieldMultiTSWithoutSDA;
+  class MEDFileInt32FieldMultiTSWithoutSDA;
+  class MEDFileInt64FieldMultiTSWithoutSDA;
   class MEDFileFloatFieldMultiTSWithoutSDA;
   
   template<>
@@ -67,8 +69,8 @@ namespace MEDCoupling
   template<>
   struct MEDLOADER_EXPORT MLFieldTraits<Int32>
   {
-    typedef MEDFileIntFieldMultiTSWithoutSDA FMTSWSDAType;
-    typedef MEDFileIntFieldMultiTS FMTSType;
+    typedef MEDFileInt32FieldMultiTSWithoutSDA FMTSWSDAType;
+    typedef MEDFileInt32FieldMultiTS FMTSType;
     typedef MEDFileInt32Field1TS F1TSType;
     typedef MEDFileInt32Field1TSWithoutSDA F1TSWSDAType;
   };
@@ -76,8 +78,8 @@ namespace MEDCoupling
   template<>
   struct MEDLOADER_EXPORT MLFieldTraits<Int64>
   {
-    //typedef MEDFileIntFieldMultiTSWithoutSDA FMTSWSDAType;
-    //typedef MEDFileIntFieldMultiTS FMTSType;
+    typedef MEDFileInt64FieldMultiTSWithoutSDA FMTSWSDAType;
+    typedef MEDFileInt64FieldMultiTS FMTSType;
     typedef MEDFileInt64Field1TS F1TSType;
     typedef MEDFileInt64Field1TSWithoutSDA F1TSWSDAType;
   };