scilab/modules/hdf5/src/cpp/HDF5Scilab.hxx

   1 /*
   2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  * Copyright (C) 2012 - Scilab Enterprises - Calixte DENIZET
   4  *
   5  * This file must be used under the terms of the CeCILL.
   6  * This source file is licensed as described in the file COPYING, which
   7  * you should have received as part of this distribution.  The terms
   8  * are also available at
   9  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  10  *
  11  */
  12
  13 #ifndef __HDF5SCILAB_HXX__
  14 #define __HDF5SCILAB_HXX__
  15
  16 #include <vector>
  17
  18 #include "H5Object.hxx"
  19 #include "H5File.hxx"
  20 #include "H5Group.hxx"
  21 #include "H5Dataset.hxx"
  22 #include "H5Attribute.hxx"
  23 #include "H5Data.hxx"
  24 #include "H5VariableScope.hxx"
  25
  26 extern "C"
  27 {
  28 #include "api_scilab.h"
  29 #include "Scierror.h"
  30 #include "HDF5Objects.h"
  31 #include "sciprint.h"
  32 #include "localization.h"
  33 }
  34
  35 namespace org_modules_hdf5
  36 {
  37
  38 class HDF5Scilab
  39 {
  40
  41 public:
  42
  43     static int getH5ObjectId(int * mlist, void * pvApiCtx);
  44
  45     static H5Object * getH5Object(int * mlist, void * pvApiCtx);
  46
  47     static bool isH5Object(int * mlist, void * pvApiCtx);
  48
  49     static void scilabPrint(const std::string & str);
  50
  51     static void split(const std::string & str, std::vector<std::string> & v, const char c = '\n');
  52
  53     static void readData(const std::string & filename, const std::string & name, int pos, void * pvApiCtx);
  54
  55     static void readData(H5Object & obj, const std::string & name, int pos, void * pvApiCtx);
  56
  57     static void readAttributeData(H5Object & obj, const std::string & path, const std::string & attrName, int pos, void * pvApiCtx);
  58
  59     static void readAttributeData(const std::string & filename, const std::string & path, const std::string & attrName, int pos, void * pvApiCtx);
  60
  61     static void deleteLink(H5Object & parent, const std::string & name);
  62
  63     static void createLink(H5Object & parent, const std::string & name, const std::string & targetPath, const bool hard);
  64
  65     static void createLink(H5Object & parent, const std::string & name, H5Object & targetObject, const bool hard);
  66
  67     static void createLink(H5Object & parent, const std::string & name, const std::string & targetFile, const std::string & targetPath);
  68
  69     static void createLink(H5Object & parent, const std::string & name, H5Object & targetObject);
  70
  71     template <typename T, typename U>
  72     static U & create(H5Object & parent, const std::string & name, const unsigned int rank, const hsize_t * dims, const hsize_t * maxdims, T * data, const hid_t targetType)
  73     {
  74         hid_t obj;
  75         hid_t space;
  76         hid_t type;
  77         hid_t targettype;
  78         herr_t err;
  79         H5Object * loc = 0;
  80         hsize_t * _maxdims = 0;
  81         bool mustDelete = false;
  82         H5T_conv_t conv;
  83         H5T_cdata_t * pcdata = 0;
  84
  85         if (rank > __SCILAB_HDF5_MAX_DIMS__)
  86         {
  87             throw H5Exception(__LINE__, __FILE__, _("Invalid rank, must be in the interval [0, %d]."), __SCILAB_HDF5_MAX_DIMS__);
  88         }
  89
  90         if (parent.isFile())
  91         {
  92             loc = &reinterpret_cast<H5File *>(&parent)->getRoot();
  93         }
  94         else
  95         {
  96             loc = &parent;
  97         }
  98
  99         type = H5Type::getBaseType(data);
 100         if (type < 0)
 101         {
 102             throw H5Exception(__LINE__, __FILE__, _("Cannot create a data type."));
 103         }
 104
 105         if (targetType == (hid_t) - 1)
 106         {
 107             targettype = type;
 108         }
 109         else
 110         {
 111             targettype = targetType;
 112         }
 113
 114         if (!H5Tfind(type, targettype, &pcdata))
 115         {
 116             H5Tclose(type);
 117             throw H5Exception(__LINE__, __FILE__, _("No converter found for the specified target datatype."));
 118         }
 119
 120         if (!maxdims)
 121         {
 122             _maxdims = new hsize_t[rank];
 123             memcpy(_maxdims, dims, rank * sizeof(hsize_t));
 124             mustDelete = true;
 125         }
 126         else
 127         {
 128             _maxdims = const_cast<hsize_t *>(maxdims);
 129         }
 130
 131         space = H5Screate_simple(rank, dims, maxdims);
 132         if (mustDelete)
 133         {
 134             delete[] _maxdims;
 135         }
 136
 137         if (space < 0)
 138         {
 139             H5Tclose(type);
 140             throw H5Exception(__LINE__, __FILE__, _("Cannot create a new dataspace."));
 141         }
 142
 143         try
 144         {
 145             obj = U::create(*loc, name, type, targettype, space, data);
 146             H5Tclose(type);
 147             H5Sclose(space);
 148         }
 149         catch (H5Exception & e)
 150         {
 151             H5Tclose(type);
 152             H5Sclose(space);
 153             throw;
 154         }
 155
 156         return *new U(*loc, obj, name);
 157     }
 158
 159     template <typename T, typename U>
 160     static U & create(H5Object & parent, const std::string & name, const unsigned int rank, const hsize_t * dims, const hsize_t * maxdims, T * data, const std::string & targetType)
 161     {
 162         hid_t targettype;
 163         if (targetType.empty())
 164         {
 165             targettype = (hid_t) - 1;
 166         }
 167         else
 168         {
 169             targettype = H5Type::getBaseType(targetType);
 170             if (targettype < 0)
 171             {
 172                 throw H5Exception(__LINE__, __FILE__, _("Cannot create the target type."));
 173             }
 174         }
 175
 176         try
 177         {
 178             U & obj = create<T, U>(parent, name, rank, dims, maxdims, data, targettype);
 179             if (targettype >= 0)
 180             {
 181                 H5Tclose(targettype);
 182             }
 183             return obj;
 184         }
 185         catch (H5Exception & e)
 186         {
 187             if (targettype >= 0)
 188             {
 189                 H5Tclose(targettype);
 190             }
 191             throw;
 192         }
 193     }
 194 };
 195 }
 196
 197 #endif // __HDF5SCILAB_HXX__