scilab/modules/hdf5/src/c/h5_writeDataToFile.c

   1 /*
   2 *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3 *  Copyright (C) 2012 - Scilab Enterprises - Antoine ELIAS
   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 #define H5_USE_16_API
  14
  15 #include <hdf5.h>
  16 #include <MALLOC.h>
  17 #include <math.h>
  18 #include <string.h>
  19 #include <stdlib.h>
  20 #include "sci_types.h"
  21 #include "version.h"
  22 #include "core_math.h"
  23 #include "h5_writeDataToFile.h"
  24 #include "h5_readDataFromFile.h"
  25 #include "h5_attributeConstants.h"
  26 #include "doublecomplex.h"
  27 #include "stack3.h"
  28
  29 static hid_t enableCompression(int _iLevel, int _iRank, const hsize_t * _piDims)
  30 {
  31     /*hid_t iRet = 0;
  32     int iLevel = _iLevel;*/
  33
  34     return H5P_DEFAULT;
  35     /*
  36       if(iLevel < 0)
  37         {
  38             iLevel = 0;
  39         }
  40
  41       if(iLevel > 9)
  42         {
  43             iLevel = 9;
  44         }
  45
  46         if(iLevel)
  47         {
  48             iRet = H5Pcreate(H5P_DATASET_CREATE);
  49             if(iRet < 0)
  50             {
  51                 iRet = 0;
  52             }
  53             else
  54             {
  55                 if(H5Pset_layout(iRet,H5D_COMPACT)<0)
  56                 {
  57                     H5Pclose(iRet);
  58                     iRet = 0;
  59                 }
  60                 else
  61                 {
  62                     if(H5Pset_chunk(iRet,_iRank, _piDims)<0)
  63                     {
  64                         H5Pclose(iRet);
  65                         iRet = 0;
  66                     }
  67                     else
  68                     {
  69                         if(H5Pset_deflate(iRet,iLevel)<0)
  70                         {
  71                             H5Pclose(iRet);
  72                             iRet = 0;
  73                         }
  74                     }
  75                 }
  76             }
  77         }
  78         else
  79         {
  80             iRet = H5Pcopy(H5P_DEFAULT);
  81         }
  82         return iRet;
  83     */
  84 }
  85
  86 static hsize_t* convertDims(int _iDims, int* _piDims, int* _piSize)
  87 {
  88     int iSize = 1;
  89     int i = 0;
  90     hsize_t* piDims = (hsize_t*)malloc(sizeof(hsize_t) * _iDims);
  91     for(i = 0 ; i < _iDims ; i++)
  92     {//reverse dimensions to improve rendering in external tools
  93         piDims[i] = _piDims[_iDims - 1 - i];
  94         iSize *= (int)piDims[i];
  95     }
  96
  97     *_piSize = iSize;
  98     return piDims;
  99 }
 100
 101 static herr_t addIntAttribute(int _iDatasetId, const char *_pstName, const int _iVal)
 102 {
 103     hsize_t attributeDims[1] = { 1 };
 104     hid_t attributeTypeId, attributeSpace;
 105     herr_t status;
 106
 107     //Create attribute dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 108     attributeSpace = H5Screate_simple(1, attributeDims, NULL);
 109
 110     //Create the attribute and write it.
 111     attributeTypeId = H5Acreate(_iDatasetId, _pstName, H5T_NATIVE_INT, attributeSpace, H5P_DEFAULT);
 112     if (attributeTypeId < 0)
 113     {
 114         return -1;
 115     }
 116
 117     status = H5Awrite(attributeTypeId, H5T_NATIVE_INT, &_iVal);
 118     if (status < 0)
 119     {
 120         return -1;
 121     }
 122
 123     //Close and release resources.
 124     status = H5Aclose(attributeTypeId);
 125     if (status < 0)
 126     {
 127         return -1;
 128     }
 129
 130     status = H5Sclose(attributeSpace);
 131     if (status < 0)
 132     {
 133         return -1;
 134     }
 135
 136     return 0;
 137 }
 138
 139 static herr_t addAttribute(int _iDatasetId, const char *_pstName, const char *_pstValue)
 140 {
 141     hsize_t attributeDims[1] = { 1 };
 142     hid_t attributeTypeId, attributeSpace, attr;
 143     herr_t status;
 144
 145     //Create attribute dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 146     attributeSpace = H5Screate_simple(1, attributeDims, NULL);
 147
 148     //Create special attribute type
 149     attributeTypeId = H5Tcopy(H5T_C_S1);
 150     status = H5Tset_size(attributeTypeId, strlen(_pstValue));
 151     if (status < 0)
 152     {
 153         return -1;
 154     }
 155
 156     //Create the attribute and write it.
 157     attr = H5Acreate(_iDatasetId, _pstName, attributeTypeId, attributeSpace, H5P_DEFAULT);
 158     if (attr < 0)
 159     {
 160         return -1;
 161     }
 162
 163     status = H5Awrite(attr, attributeTypeId, _pstValue);
 164     if (status < 0)
 165     {
 166         return -1;
 167     }
 168
 169     //Close and release resources.
 170     status = H5Aclose(attr);
 171     if (status < 0)
 172     {
 173         return -1;
 174     }
 175
 176     status = H5Tclose(attributeTypeId);
 177     if (status < 0)
 178     {
 179         return -1;
 180     }
 181
 182     return 0;
 183 }
 184
 185
 186 int updateScilabVersion(int _iFile)
 187 {
 188     herr_t status;
 189     //try to read attribute
 190     char* pstScilabVersion = getScilabVersionAttribute(_iFile);
 191     if (pstScilabVersion)
 192     {
 193         //delete before write
 194         status = H5Adelete(_iFile, g_SCILAB_CLASS_SCI_VERSION);
 195         if (status < 0)
 196         {
 197             return -1;
 198         }
 199     }
 200
 201     if (strstr(SCI_VERSION_STRING, "branch"))
 202     {
 203         //compiled by user
 204         char pstVersion[64];
 205         sprintf(pstVersion, "%s %d.%d.%d", SCI_VERSION_STRING, SCI_VERSION_MAJOR, SCI_VERSION_MINOR, SCI_VERSION_MAINTENANCE);
 206         status = addAttribute(_iFile, g_SCILAB_CLASS_SCI_VERSION, pstVersion);
 207     }
 208     else
 209     {
 210         //compiled by compilation chain
 211         status = addAttribute(_iFile, g_SCILAB_CLASS_SCI_VERSION, SCI_VERSION_STRING);
 212     }
 213
 214     return status;
 215 }
 216
 217 int updateFileVersion(int _iFile)
 218 {
 219     herr_t status;
 220     //try to read attribute
 221     int iHdf5Version = getSODFormatAttribute(_iFile);
 222     if (iHdf5Version != -1)
 223     {
 224         status = H5Adelete(_iFile, g_SCILAB_CLASS_SOD_VERSION);
 225         if (status < 0)
 226         {
 227             return -1;
 228         }
 229     }
 230
 231     return addIntAttribute(_iFile, g_SCILAB_CLASS_SOD_VERSION, SOD_FILE_VERSION);
 232 }
 233
 234 int writeStringMatrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, char **data)
 235 {
 236     int iSize = 0;
 237     hsize_t* piDims = NULL;
 238     hid_t typeId, space, dset;
 239     herr_t status;
 240     hid_t iCompress;
 241
 242     piDims = convertDims(_iDims, _piDims, &iSize);
 243     //Create string dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 244     space = H5Screate_simple(_iDims, piDims, NULL);
 245     if (space < 0)
 246     {
 247         FREE(piDims);
 248         return -1;
 249     }
 250
 251     //Create special string type
 252     typeId = H5Tcopy(H5T_C_S1);
 253     status = H5Tset_size(typeId, H5T_VARIABLE);
 254     if (status < 0)
 255     {
 256         FREE(piDims);
 257         return -1;
 258     }
 259
 260     //Create the data set and write it.
 261     iCompress = enableCompression(9, _iDims, piDims);
 262     FREE(piDims);
 263     dset = H5Dcreate(_iFile, _pstDatasetName, typeId, space, iCompress);
 264     if (dset < 0)
 265     {
 266         return -1;
 267     }
 268
 269     status = H5Dwrite(dset, typeId, H5S_ALL, H5S_ALL, H5P_DEFAULT, data);
 270     if (status < 0)
 271     {
 272         return -1;
 273     }
 274
 275     //Add attribute SCILAB_Class = string to dataset
 276     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_STRING);
 277     if (status < 0)
 278     {
 279         return -1;
 280     }
 281
 282     //Close and release resources.
 283     status = H5Dclose(dset);
 284     if (status < 0)
 285     {
 286         return -1;
 287     }
 288
 289     status = H5Tclose(typeId);
 290     if (status < 0)
 291     {
 292         return -1;
 293     }
 294
 295     return 0;
 296 }
 297
 298 char *createGroupName(char *_pstGroupName)
 299 {
 300     char *pstSlash = NULL;
 301     char *pstGroupName = (char *)MALLOC((strlen(_pstGroupName) + 3) * sizeof(char));
 302
 303     // Generate groupname #<dataSetName>#
 304     sprintf(pstGroupName, "#%s#", _pstGroupName);
 305     pstSlash = strstr(pstGroupName, "/");
 306     if (pstSlash != NULL)
 307     {
 308         pstSlash[0] = '_';
 309     }
 310
 311     return pstGroupName;
 312 }
 313
 314 char* createPathName(char *_pstGroupName, int _iIndex)
 315 {
 316     char *pstName = NULL;
 317     char *pstPathName = NULL;
 318
 319     int iNameLen = (int)log10((double)_iIndex + 1) + 1;
 320     iNameLen += 2; //for both '#'
 321     iNameLen += 1; //for null termanation
 322
 323     pstName = (char *)MALLOC(iNameLen * sizeof(char));
 324     //1 for null termination, 2 for '#' characters
 325     sprintf(pstName, "#%d#", _iIndex);
 326
 327     pstPathName = (char *)MALLOC((strlen(_pstGroupName) + strlen(pstName) + 2) * sizeof(char));
 328     //1 for null termination, 1 for separator, 2 for '#' characters
 329     sprintf(pstPathName, "%s/%s", _pstGroupName, pstName);
 330     FREE(pstName);
 331     return pstPathName;
 332 }
 333
 334 int writeVoid(int _iFile, char *_pstDatasetName)
 335 {
 336     hsize_t piDims[1] = { 1 };
 337     herr_t status = 0;
 338     hid_t iSpace = 0;
 339     hid_t iDataset = 0;
 340     hid_t iCompress = 0;
 341     char cData = 0;
 342
 343     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 344     iSpace = H5Screate_simple(1, piDims, NULL);
 345     if (iSpace < 0)
 346     {
 347         return -1;
 348     }
 349     //Create the dataset and write the array data to it.
 350     iCompress = enableCompression(9, 1, piDims);
 351     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT8, iSpace, iCompress);
 352     if (iDataset < 0)
 353     {
 354         return -1;
 355     }
 356
 357     status = H5Dwrite(iDataset, H5T_NATIVE_INT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, &cData);
 358     if (status < 0)
 359     {
 360         return -1;
 361     }
 362
 363     //Add attribute SCILAB_Class = double to dataset
 364     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_VOID);
 365     if (status < 0)
 366     {
 367         return -1;
 368     }
 369
 370     //Close and release resources.
 371     status = H5Dclose(iDataset);
 372     if (status < 0)
 373     {
 374         return -1;
 375     }
 376
 377     status = H5Sclose(iSpace);
 378     if (status < 0)
 379     {
 380         return -1;
 381     }
 382
 383     return 0;
 384 }
 385
 386 int writeUndefined(int _iFile, char *_pstDatasetName)
 387 {
 388     hsize_t piDims[1] = { 1 };
 389     herr_t status = 0;
 390     hid_t iSpace = 0;
 391     hid_t iDataset = 0;
 392     hid_t iCompress = 0;
 393     char cData = 0;
 394
 395     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 396     iSpace = H5Screate_simple(1, piDims, NULL);
 397     if (iSpace < 0)
 398     {
 399         return -1;
 400     }
 401     //Create the dataset and write the array data to it.
 402     iCompress = enableCompression(9, 1, piDims);
 403     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT8, iSpace, iCompress);
 404     if (iDataset < 0)
 405     {
 406         return -1;
 407     }
 408
 409     status = H5Dwrite(iDataset, H5T_NATIVE_INT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, &cData);
 410     if (status < 0)
 411     {
 412         return -1;
 413     }
 414
 415     //Add attribute SCILAB_Class = double to dataset
 416     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_UNDEFINED);
 417     if (status < 0)
 418     {
 419         return -1;
 420     }
 421
 422     //Close and release resources.
 423     status = H5Dclose(iDataset);
 424     if (status < 0)
 425     {
 426         return -1;
 427     }
 428
 429     status = H5Sclose(iSpace);
 430     if (status < 0)
 431     {
 432         return -1;
 433     }
 434
 435     return 0;
 436 }
 437
 438 static hobj_ref_t writeCommomDoubleMatrix(int _iFile, char *_pstGroupName, char *_pstDatasetName, int _iIndex, int _iRows, int _iCols,
 439         double *_pdblData)
 440 {
 441     hid_t space;
 442     hid_t dset;
 443     hid_t iCompress = 0;
 444     hsize_t dims[1] = { _iRows * _iCols };
 445     herr_t status = 0;
 446     hobj_ref_t iRef = 0;
 447
 448     if (_iRows * _iCols == 0)
 449     {
 450         double dblZero = 0;
 451
 452         //tips for empty double matrix
 453
 454         //Create dataspace.  Setting maximum size to NULL sets the maximum
 455         //size to be the current size.
 456         dims[0] = 1;
 457
 458         space = H5Screate_simple(1, dims, NULL);
 459         if (space < 0)
 460         {
 461             return (hobj_ref_t) (-1);
 462         }
 463
 464         //Create the dataset and write the array data to it.
 465         iCompress = enableCompression(9, 1, dims);
 466         dset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_DOUBLE, space, iCompress);
 467         if (dset < 0)
 468         {
 469             return (hobj_ref_t) (-1);
 470         }
 471
 472         status = H5Dwrite(dset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, &dblZero);
 473         if (status < 0)
 474         {
 475             return (hobj_ref_t) (-1);
 476         }
 477
 478         //Add attribute SCILAB_Class = double to dataset
 479         status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_DOUBLE);
 480         if (status < 0)
 481         {
 482             return (hobj_ref_t) (-1);
 483         }
 484
 485         status = addAttribute(dset, g_SCILAB_CLASS_EMPTY, "true");
 486         if (status < 0)
 487         {
 488             return (hobj_ref_t) (-1);
 489         }
 490     }
 491     else
 492     {
 493         char *pstPathName = NULL;
 494
 495         //Create dataspace.  Setting maximum size to NULL sets the maximum
 496         //size to be the current size.
 497         space = H5Screate_simple(1, dims, NULL);
 498         if (space < 0)
 499         {
 500             return (hobj_ref_t) (-1);
 501         }
 502
 503         //createGroupe and dataset name
 504         pstPathName = createPathName(_pstGroupName, _iIndex);
 505
 506         //Create the dataset and write the array data to it.
 507         iCompress = enableCompression(9, 1, dims);
 508         dset = H5Dcreate(_iFile, pstPathName, H5T_NATIVE_DOUBLE, space, iCompress);
 509         if (dset < 0)
 510         {
 511             FREE(pstPathName);
 512             return (hobj_ref_t) (-1);
 513         }
 514
 515         status = H5Dwrite(dset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pdblData);
 516         if (status < 0)
 517         {
 518             FREE(pstPathName);
 519             return (hobj_ref_t) (-1);
 520         }
 521
 522         //Add attribute SCILAB_Class = double to dataset
 523         status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_DOUBLE);
 524         if (status < 0)
 525         {
 526             FREE(pstPathName);
 527             return (hobj_ref_t) (-1);
 528         }
 529
 530         //Add attribute SCILAB_Class_rows = double to dataset
 531         status = addIntAttribute(dset, g_SCILAB_CLASS_ROWS, _iRows);
 532         if (status < 0)
 533         {
 534             FREE(pstPathName);
 535             return (hobj_ref_t) (-1);
 536         }
 537
 538         //Add attribute SCILAB_Class_cols = double to dataset
 539         status = addIntAttribute(dset, g_SCILAB_CLASS_COLS, _iCols);
 540         if (status < 0)
 541         {
 542             FREE(pstPathName);
 543             return (hobj_ref_t) (-1);
 544         }
 545
 546         // create the ref
 547         status = H5Rcreate(&iRef, _iFile, pstPathName, H5R_OBJECT, -1);
 548         if (status < 0)
 549         {
 550             FREE(pstPathName);
 551             return (hobj_ref_t) (-1);
 552         }
 553
 554         FREE(pstPathName);
 555     }
 556
 557     //Close and release resources.
 558     status = H5Dclose(dset);
 559     if (status < 0)
 560     {
 561         return (hobj_ref_t) (-1);
 562     }
 563
 564     status = H5Sclose(space);
 565     if (status < 0)
 566     {
 567         return (hobj_ref_t) (-1);
 568     }
 569
 570     return iRef;
 571 }
 572
 573 int writeDoubleMatrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, double *_pdblData)
 574 {
 575     hid_t space = 0;
 576     hid_t dset = 0;
 577     herr_t status = 0;
 578     hsize_t *piDims = NULL;
 579     hid_t iCompress = 0;
 580     int i = 0;
 581     int iSize = 0;
 582
 583     piDims = convertDims(_iDims, _piDims, &iSize);
 584
 585     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 586     space = H5Screate_simple(_iDims, piDims, NULL);
 587     if (space < 0)
 588     {
 589         free(piDims);
 590         return -1;
 591     }
 592
 593     //Create the dataset and write the array data to it.
 594     iCompress = enableCompression(9, _iDims, piDims);
 595     free(piDims);
 596
 597     dset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_DOUBLE, space, iCompress);
 598     if (dset < 0)
 599     {
 600         return -1;
 601     }
 602
 603     status = H5Dwrite(dset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pdblData);
 604     if (status < 0)
 605     {
 606         return -1;
 607     }
 608
 609     //Add attribute SCILAB_Class = double to dataset
 610     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_DOUBLE);
 611     if (status < 0)
 612     {
 613         return -1;
 614     }
 615
 616     //Close and release resources.
 617     status = H5Dclose(dset);
 618     if (status < 0)
 619     {
 620         return -1;
 621     }
 622
 623     status = H5Sclose(space);
 624     if (status < 0)
 625     {
 626         return -1;
 627     }
 628
 629     return status;
 630 }
 631
 632 int writeDoubleComplexMatrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, double *_pdblReal, double *_pdblImg)
 633 {
 634     hid_t space = 0;
 635     hid_t dset = 0;
 636     herr_t status = 0;
 637     hsize_t *piDims = NULL;
 638     hid_t iCompress = 0;
 639     hid_t compoundId;
 640     int iSize = 1;
 641     doublecomplex* pData = NULL;
 642
 643     //create sub group only for non empty matrix
 644     if (_iDims == 2 && _piDims[0] == 0 && _piDims[1] == 0)
 645     {// [] complex
 646         //a revoir
 647         return -1;
 648     }
 649
 650     compoundId = H5Tcreate (H5T_COMPOUND, sizeof(doublecomplex));
 651     H5Tinsert(compoundId, "real", HOFFSET(doublecomplex, r), H5T_NATIVE_DOUBLE);
 652     H5Tinsert(compoundId, "imag", HOFFSET(doublecomplex, i), H5T_NATIVE_DOUBLE);
 653     piDims = convertDims(_iDims, _piDims, &iSize);
 654
 655     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 656     space = H5Screate_simple(_iDims, piDims, NULL);
 657     if (space < 0)
 658     {
 659         free(piDims);
 660         return -1;
 661     }
 662
 663     //Create the dataset and write the array data to it.
 664     iCompress = enableCompression(9, _iDims, piDims);
 665     free(piDims);
 666
 667     dset = H5Dcreate(_iFile, _pstDatasetName, compoundId, space, iCompress);
 668     if (dset < 0)
 669     {
 670         return -1;
 671     }
 672
 673     //convert double data doublecomplex data
 674     pData = oGetDoubleComplexFromPointer(_pdblReal, _pdblImg, iSize);
 675     status = H5Dwrite(dset, compoundId, H5S_ALL, H5S_ALL, H5P_DEFAULT, pData);
 676     FREE(pData);
 677     if (status < 0)
 678     {
 679         return -1;
 680     }
 681
 682     //Add attribute SCILAB_Class = double to dataset
 683     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_DOUBLE);
 684     if (status < 0)
 685     {
 686         return -1;
 687     }
 688
 689     //Close and release resources.
 690     status = H5Dclose(dset);
 691     if (status < 0)
 692     {
 693         return -1;
 694     }
 695
 696     status = H5Sclose(space);
 697     if (status < 0)
 698     {
 699         return -1;
 700     }
 701
 702     return status;
 703 }
 704
 705 int writeBooleanMatrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, int *_piData)
 706 {
 707     int iSize = 0;
 708     hsize_t* piDims = NULL;
 709     herr_t status;
 710     hid_t iSpace;
 711     hid_t iCompress;
 712     hid_t iDataset;
 713
 714     piDims = convertDims(_iDims, _piDims, &iSize);
 715
 716     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 717     iSpace = H5Screate_simple(_iDims, piDims, NULL);
 718     if (iSpace < 0)
 719     {
 720         return -1;
 721     }
 722
 723     //Create the dataset and write the array data to it.
 724     iCompress = enableCompression(9, _iDims, piDims);
 725     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT, iSpace, iCompress);
 726     if (iDataset < 0)
 727     {
 728         return -1;
 729     }
 730
 731     status = H5Dwrite(iDataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, _piData);
 732     if (status < 0)
 733     {
 734         return -1;
 735     }
 736
 737     //Add attribute SCILAB_Class = double to dataset
 738     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_BOOLEAN);
 739     if (status < 0)
 740     {
 741         return -1;
 742     }
 743
 744     //Close and release resources.
 745     status = H5Dclose(iDataset);
 746     if (status < 0)
 747     {
 748         return -1;
 749     }
 750
 751     status = H5Sclose(iSpace);
 752     if (status < 0)
 753     {
 754         return -1;
 755     }
 756
 757     return 0;
 758 }
 759
 760 static int writeCommonPolyMatrix(int _iFile, char *_pstDatasetName, char *_pstVarName, int _iComplex, int _iDims, int* _piDims, int *_piNbCoef, double **_pdblReal, double **_pdblImg)
 761 {
 762     int i = 0;
 763     hsize_t* piDims = NULL;
 764     herr_t status = 0;
 765     hid_t space = 0;
 766     hid_t dset = 0;
 767     hid_t group = 0;
 768     hid_t iCompress = 0;
 769     hobj_ref_t *pData = 0;
 770     int iSize = 0;
 771
 772     char *pstPathName = NULL;
 773     char *pstGroupName = NULL;
 774
 775     piDims = convertDims(_iDims, _piDims, &iSize);
 776     // Create ref matrix
 777     pData = (hobj_ref_t *)MALLOC(iSize * sizeof(hobj_ref_t));
 778
 779     // Generate groupname #<dataSetName>#
 780     pstGroupName = createGroupName(_pstDatasetName);
 781
 782     //First create a group to store all referenced objects.
 783     group = H5Gcreate(_iFile, pstGroupName, H5P_DEFAULT);
 784     status = H5Gclose(group);
 785
 786     //Now create each String as a dedicated DataSet.
 787     for (i = 0 ; i < iSize ; i++)
 788     {
 789         pstPathName = createPathName(pstGroupName, i);
 790
 791         // Write the string to ref
 792         if (_iComplex)
 793         {
 794             status = writeDoubleComplexMatrix(_iFile, pstPathName, 1, &_piNbCoef[i], _pdblReal[i], _pdblImg[i]);
 795         }
 796         else
 797         {
 798             status = writeDoubleMatrix(_iFile, pstPathName, 1, &_piNbCoef[i], _pdblReal[i]);
 799         }
 800
 801         if (status < 0)
 802         {
 803             FREE(pstPathName);
 804             FREE(pstGroupName);
 805             FREE(pData);
 806             FREE(piDims);
 807            return -1;
 808         }
 809
 810         // create the ref
 811         status = H5Rcreate(&pData[i], _iFile, pstPathName, H5R_OBJECT, -1);
 812         if (status < 0)
 813         {
 814             FREE(pstPathName);
 815             FREE(pstGroupName);
 816             FREE(pData);
 817             FREE(piDims);
 818             return -1;
 819         }
 820
 821         FREE(pstPathName);
 822     }
 823
 824     FREE(pstGroupName);
 825     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 826     space = H5Screate_simple(_iDims, piDims, NULL);
 827     if (status < 0)
 828     {
 829         FREE(piDims);
 830         FREE(pData);
 831         return -1;
 832     }
 833
 834     //Create the dataset and write the array data to it.
 835     iCompress = enableCompression(9, _iDims, piDims);
 836     FREE(piDims);
 837     dset = H5Dcreate(_iFile, _pstDatasetName, H5T_STD_REF_OBJ, space, iCompress);
 838     if (dset < 0)
 839     {
 840         FREE(pData);
 841         return -1;
 842     }
 843
 844     status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pData);
 845     if (status < 0)
 846     {
 847         FREE(pData);
 848         return -1;
 849     }
 850
 851     FREE(pData);
 852     //Add attribute SCILAB_Class = poly to dataset
 853     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_POLY);
 854     if (status < 0)
 855     {
 856         return -1;
 857     }
 858
 859     //Add attribute Varname attribute to dataset
 860     status = addAttribute(dset, g_SCILAB_CLASS_VARNAME, _pstVarName);
 861     if (status < 0)
 862     {
 863         return -1;
 864     }
 865
 866     if (_iComplex)
 867     {
 868         //Add attribute Varname attribute to dataset
 869         status = addAttribute(dset, g_SCILAB_CLASS_COMPLEX, "true");
 870         if (status < 0)
 871         {
 872             return -1;
 873         }
 874     }
 875
 876     //Close and release resources.
 877     status = H5Dclose(dset);
 878     if (status < 0)
 879     {
 880         return -1;
 881     }
 882
 883     status = H5Sclose(space);
 884     if (status < 0)
 885     {
 886         return -1;
 887     }
 888
 889     return 0;
 890 }
 891
 892 int writePolyMatrix(int _iFile, char *_pstDatasetName, char *_pstVarName, int _iDims, int* _piDims, int *_piNbCoef, double **_pdblReal)
 893 {
 894     return writeCommonPolyMatrix(_iFile, _pstDatasetName, _pstVarName, 0, _iDims, _piDims, _piNbCoef, _pdblReal, NULL);
 895 }
 896
 897 int writePolyComplexMatrix(int _iFile, char *_pstDatasetName, char *_pstVarName, int _iDims, int* _piDims, int *_piNbCoef, double **_pdblReal,
 898                            double **_pdblImg)
 899 {
 900     return writeCommonPolyMatrix(_iFile, _pstDatasetName, _pstVarName, 1, _iDims, _piDims, _piNbCoef, _pdblReal, _pdblImg);
 901 }
 902
 903 int writeInteger8Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, char *_pcData)
 904 {
 905     hsize_t* piDims = NULL;
 906     herr_t status = 0;
 907     hid_t iSpace = 0;
 908     hid_t iDataset = 0;
 909     hid_t iCompress = 0;
 910     int iSize = 0;
 911
 912     piDims = convertDims(_iDims, _piDims, &iSize);
 913
 914     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 915     iSpace = H5Screate_simple(_iDims, piDims, NULL);
 916     if (iSpace < 0)
 917     {
 918         FREE(piDims);
 919         return -1;
 920     }
 921     //Create the dataset and write the array data to it.
 922     iCompress = enableCompression(9, _iDims, piDims);
 923     FREE(piDims);
 924     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT8, iSpace, iCompress);
 925     if (iDataset < 0)
 926     {
 927         return -1;
 928     }
 929
 930     status = H5Dwrite(iDataset, H5T_NATIVE_INT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pcData);
 931     if (status < 0)
 932     {
 933         return -1;
 934     }
 935
 936     //Add attribute SCILAB_Class = double to dataset
 937     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
 938     if (status < 0)
 939     {
 940         return -1;
 941     }
 942
 943     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "8");
 944     if (status < 0)
 945     {
 946         return -1;
 947     }
 948
 949     //Close and release resources.
 950     status = H5Dclose(iDataset);
 951     if (status < 0)
 952     {
 953         return -1;
 954     }
 955
 956     status = H5Sclose(iSpace);
 957     if (status < 0)
 958     {
 959         return -1;
 960     }
 961
 962     return 0;
 963 }
 964
 965 int writeInteger16Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, short *_psData)
 966 {
 967     hsize_t* piDims = NULL;
 968     herr_t status = 0;
 969     hid_t iSpace = 0;
 970     hid_t iDataset = 0;
 971     hid_t iCompress = 0;
 972     int iSize = 0;
 973
 974     piDims = convertDims(_iDims, _piDims, &iSize);
 975
 976     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
 977     iSpace = H5Screate_simple(_iDims, piDims, NULL);
 978     if (iSpace < 0)
 979     {
 980         FREE(piDims);
 981         return -1;
 982     }
 983     //Create the dataset and write the array data to it.
 984     iCompress = enableCompression(9, _iDims, piDims);
 985     FREE(piDims);
 986     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT16, iSpace, iCompress);
 987     if (iDataset < 0)
 988     {
 989         return -1;
 990     }
 991     status = H5Dwrite(iDataset, H5T_NATIVE_INT16, H5S_ALL, H5S_ALL, H5P_DEFAULT, _psData);
 992     if (status < 0)
 993     {
 994         return -1;
 995     }
 996
 997     //Add attribute SCILAB_Class = double to dataset
 998     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
 999     if (status < 0)
1000     {
1001         return -1;
1002     }
1003
1004     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "16");
1005     if (status < 0)
1006     {
1007         return -1;
1008     }
1009
1010     //Close and release resources.
1011     status = H5Dclose(iDataset);
1012     if (status < 0)
1013     {
1014         return -1;
1015     }
1016
1017     status = H5Sclose(iSpace);
1018     if (status < 0)
1019     {
1020         return -1;
1021     }
1022
1023     return 0;
1024 }
1025
1026 int writeInteger32Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, int *_piData)
1027 {
1028     hsize_t* piDims = NULL;
1029     herr_t status = 0;
1030     hid_t iSpace = 0;
1031     hid_t iDataset = 0;
1032     hid_t iCompress = 0;
1033     int iSize = 0;
1034
1035     piDims = convertDims(_iDims, _piDims, &iSize);
1036
1037     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1038     iSpace = H5Screate_simple(_iDims, piDims, NULL);
1039     if (iSpace < 0)
1040     {
1041         FREE(piDims);
1042         return -1;
1043     }
1044     //Create the dataset and write the array data to it.
1045     iCompress = enableCompression(9, _iDims, piDims);
1046     FREE(piDims);
1047     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT32, iSpace, iCompress);
1048     if (iDataset < 0)
1049     {
1050         return -1;
1051     }
1052
1053     status = H5Dwrite(iDataset, H5T_NATIVE_INT32, H5S_ALL, H5S_ALL, H5P_DEFAULT, _piData);
1054     if (status < 0)
1055     {
1056         return -1;
1057     }
1058
1059     //Add attribute SCILAB_Class = double to dataset
1060     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1061     if (status < 0)
1062     {
1063         return -1;
1064     }
1065
1066     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "32");
1067     if (status < 0)
1068     {
1069         return -1;
1070     }
1071
1072     //Close and release resources.
1073     status = H5Dclose(iDataset);
1074     if (status < 0)
1075     {
1076         return -1;
1077     }
1078
1079     status = H5Sclose(iSpace);
1080     if (status < 0)
1081     {
1082         return -1;
1083     }
1084
1085     return 0;
1086 }
1087
1088 int writeInteger64Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, long long *_pllData)
1089 {
1090     hsize_t* piDims = NULL;
1091     herr_t status = 0;
1092     hid_t iSpace = 0;
1093     hid_t iDataset = 0;
1094     hid_t iCompress = 0;
1095     int iSize = 0;
1096
1097     piDims = convertDims(_iDims, _piDims, &iSize);
1098
1099     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1100     iSpace = H5Screate_simple(_iDims, piDims, NULL);
1101     if (iSpace < 0)
1102     {
1103         FREE(piDims);
1104         return -1;
1105     }
1106     //Create the dataset and write the array data to it.
1107     iCompress = enableCompression(9, _iDims, piDims);
1108     FREE(piDims);
1109     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_INT64, iSpace, iCompress);
1110     if (iDataset < 0)
1111     {
1112         return -1;
1113     }
1114
1115     status = H5Dwrite(iDataset, H5T_NATIVE_INT64, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pllData);
1116     if (status < 0)
1117     {
1118         return -1;
1119     }
1120
1121     //Add attribute SCILAB_Class = double to dataset
1122     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1123     if (status < 0)
1124     {
1125         return -1;
1126     }
1127
1128     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "64");
1129     if (status < 0)
1130     {
1131         return -1;
1132     }
1133
1134     //Close and release resources.
1135     status = H5Dclose(iDataset);
1136     if (status < 0)
1137     {
1138         return -1;
1139     }
1140
1141     status = H5Sclose(iSpace);
1142     if (status < 0)
1143     {
1144         return -1;
1145     }
1146
1147     return 0;
1148 }
1149
1150 int writeUnsignedInteger8Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, unsigned char *_pucData)
1151 {
1152     hsize_t* piDims = NULL;
1153     herr_t status = 0;
1154     hid_t iSpace = 0;
1155     hid_t iDataset = 0;
1156     hid_t iCompress = 0;
1157     int iSize = 0;
1158
1159     piDims = convertDims(_iDims, _piDims, &iSize);
1160
1161     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1162     iSpace = H5Screate_simple(_iDims, piDims, NULL);
1163     if (iSpace < 0)
1164     {
1165         FREE(piDims);
1166         return -1;
1167     }
1168     //Create the dataset and write the array data to it.
1169     iCompress = enableCompression(9, _iDims, piDims);
1170     FREE(piDims);
1171     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_UINT8, iSpace, iCompress);
1172     if (iDataset < 0)
1173     {
1174         return -1;
1175     }
1176
1177     status = H5Dwrite(iDataset, H5T_NATIVE_UINT8, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pucData);
1178     if (status < 0)
1179     {
1180         return -1;
1181     }
1182
1183     //Add attribute SCILAB_Class = double to dataset
1184     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1185     if (status < 0)
1186     {
1187         return -1;
1188     }
1189
1190     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "u8");
1191     if (status < 0)
1192     {
1193         return -1;
1194     }
1195
1196     //Close and release resources.
1197     status = H5Dclose(iDataset);
1198     if (status < 0)
1199     {
1200         return -1;
1201     }
1202
1203     status = H5Sclose(iSpace);
1204     if (status < 0)
1205     {
1206         return -1;
1207     }
1208
1209     return 0;
1210 }
1211
1212 int writeUnsignedInteger16Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, unsigned short *_pusData)
1213 {
1214     hsize_t* piDims = NULL;
1215     herr_t status = 0;
1216     hid_t iSpace = 0;
1217     hid_t iDataset = 0;
1218     hid_t iCompress = 0;
1219     int iSize = 0;
1220
1221     piDims = convertDims(_iDims, _piDims, &iSize);
1222
1223     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1224     iSpace = H5Screate_simple(_iDims, piDims, NULL);
1225     if (iSpace < 0)
1226     {
1227         FREE(piDims);
1228         return -1;
1229     }
1230     //Create the dataset and write the array data to it.
1231     iCompress = enableCompression(9, _iDims, piDims);
1232     FREE(piDims);
1233     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_UINT16, iSpace, iCompress);
1234     if (iDataset < 0)
1235     {
1236         return -1;
1237     }
1238
1239     status = H5Dwrite(iDataset, H5T_NATIVE_UINT16, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pusData);
1240     if (status < 0)
1241     {
1242         return -1;
1243     }
1244
1245     //Add attribute SCILAB_Class = double to dataset
1246     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1247     if (status < 0)
1248     {
1249         return -1;
1250     }
1251
1252     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "u16");
1253     if (status < 0)
1254     {
1255         return -1;
1256     }
1257
1258     //Close and release resources.
1259     status = H5Dclose(iDataset);
1260     if (status < 0)
1261     {
1262         return -1;
1263     }
1264
1265     status = H5Sclose(iSpace);
1266     if (status < 0)
1267     {
1268         return -1;
1269     }
1270
1271     return 0;
1272 }
1273
1274 int writeUnsignedInteger32Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, unsigned int *_puiData)
1275 {
1276     hsize_t* piDims = NULL;
1277     herr_t status = 0;
1278     hid_t iSpace = 0;
1279     hid_t iDataset = 0;
1280     hid_t iCompress = 0;
1281     int iSize = 0;
1282
1283     piDims = convertDims(_iDims, _piDims, &iSize);
1284
1285     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1286     iSpace = H5Screate_simple(_iDims, piDims, NULL);
1287     if (iSpace < 0)
1288     {
1289         FREE(piDims);
1290         return -1;
1291     }
1292     //Create the dataset and write the array data to it.
1293     iCompress = enableCompression(9, _iDims, piDims);
1294     FREE(piDims);
1295     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_UINT32, iSpace, iCompress);
1296     if (iDataset < 0)
1297     {
1298         return -1;
1299     }
1300
1301     status = H5Dwrite(iDataset, H5T_NATIVE_UINT32, H5S_ALL, H5S_ALL, H5P_DEFAULT, _puiData);
1302     if (status < 0)
1303     {
1304         return -1;
1305     }
1306
1307     //Add attribute SCILAB_Class = double to dataset
1308     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1309     if (status < 0)
1310     {
1311         return -1;
1312     }
1313
1314     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "u32");
1315     if (status < 0)
1316     {
1317         return -1;
1318     }
1319
1320     //Close and release resources.
1321     status = H5Dclose(iDataset);
1322     if (status < 0)
1323     {
1324         return -1;
1325     }
1326
1327     status = H5Sclose(iSpace);
1328     if (status < 0)
1329     {
1330         return -1;
1331     }
1332
1333     return 0;
1334 }
1335
1336 int writeUnsignedInteger64Matrix(int _iFile, char *_pstDatasetName, int _iDims, int* _piDims, unsigned long long *_pullData)
1337 {
1338     hsize_t* piDims = NULL;
1339     herr_t status = 0;
1340     hid_t iSpace = 0;
1341     hid_t iDataset = 0;
1342     hid_t iCompress = 0;
1343     int iSize = 0;
1344
1345     piDims = convertDims(_iDims, _piDims, &iSize);
1346
1347     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1348     iSpace = H5Screate_simple(_iDims, piDims, NULL);
1349     if (iSpace < 0)
1350     {
1351         FREE(piDims);
1352         return -1;
1353     }
1354     //Create the dataset and write the array data to it.
1355     iCompress = enableCompression(9, _iDims, piDims);
1356     FREE(piDims);
1357     iDataset = H5Dcreate(_iFile, _pstDatasetName, H5T_NATIVE_UINT64, iSpace, iCompress);
1358     if (iDataset < 0)
1359     {
1360         return -1;
1361     }
1362
1363     status = H5Dwrite(iDataset, H5T_NATIVE_UINT64, H5S_ALL, H5S_ALL, H5P_DEFAULT, _pullData);
1364     if (status < 0)
1365     {
1366         return -1;
1367     }
1368
1369     //Add attribute SCILAB_Class = double to dataset
1370     status = addAttribute(iDataset, g_SCILAB_CLASS, g_SCILAB_CLASS_INT);
1371     if (status < 0)
1372     {
1373         return -1;
1374     }
1375
1376     status = addAttribute(iDataset, g_SCILAB_CLASS_PREC, "u64");
1377     if (status < 0)
1378     {
1379         return -1;
1380     }
1381
1382     //Close and release resources.
1383     status = H5Dclose(iDataset);
1384     if (status < 0)
1385     {
1386         return -1;
1387     }
1388
1389     status = H5Sclose(iSpace);
1390     if (status < 0)
1391     {
1392         return -1;
1393     }
1394
1395     return 0;
1396 }
1397
1398 int writeCommonSparseComplexMatrix(int _iFile, char *_pstDatasetName, int _iComplex, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow,
1399                                    int *_piColPos, double *_pdblReal, double *_pdblImg)
1400 {
1401     hsize_t dims[1] = { 3 };
1402     herr_t status = 0;
1403     hid_t space = 0;
1404     hid_t dset = 0;
1405     hid_t group = 0;
1406     hid_t iCompress = 0;
1407     hobj_ref_t pDataRef[3] = {0};
1408
1409     char *pstRowPath = NULL;
1410     char *pstColPath = NULL;
1411     char *pstDataPath = NULL;
1412     char *pstGroupName = NULL;
1413
1414     // Generate groupname #<dataSetName>#
1415     pstGroupName = createGroupName(_pstDatasetName);
1416
1417     //First create a group to store all referenced objects.
1418     group = H5Gcreate(_iFile, pstGroupName, H5P_DEFAULT);
1419     status = H5Gclose(group);
1420     if (status < 0)
1421     {
1422         FREE(pstGroupName);
1423         return -1;
1424     }
1425
1426     //Create each sub dataset and insert data
1427     pstRowPath = createPathName(pstGroupName, 0);
1428     status = writeInteger32Matrix(_iFile, pstRowPath, 1, &_iRows, _piNbItemRow);
1429     if (status < 0)
1430     {
1431         FREE(pstRowPath);
1432         FREE(pstGroupName);
1433         return -1;
1434     }
1435
1436     status = H5Rcreate(&pDataRef[0], _iFile, pstRowPath, H5R_OBJECT, -1);
1437     if (status < 0)
1438     {
1439         FREE(pstRowPath);
1440         FREE(pstGroupName);
1441         return -1;
1442     }
1443
1444     pstColPath = createPathName(pstGroupName, 1);
1445     status = writeInteger32Matrix(_iFile, pstColPath, 1, &_iNbItem, _piColPos);
1446     if (status < 0)
1447     {
1448         FREE(pstRowPath);
1449         FREE(pstColPath);
1450         FREE(pstGroupName);
1451         return -1;
1452     }
1453
1454     status = H5Rcreate(&pDataRef[1], _iFile, pstColPath, H5R_OBJECT, -1);
1455     if (status < 0)
1456     {
1457         FREE(pstRowPath);
1458         FREE(pstColPath);
1459         FREE(pstGroupName);
1460         return -1;
1461     }
1462
1463     pstDataPath = createPathName(pstGroupName, 2);
1464     if (_iComplex)
1465     {
1466         status = writeDoubleComplexMatrix(_iFile, pstDataPath, 1, &_iNbItem, _pdblReal, _pdblImg);
1467     }
1468     else
1469     {
1470         status = writeDoubleMatrix(_iFile, pstDataPath, 1, &_iNbItem, _pdblReal);
1471     }
1472
1473     if (status < 0)
1474     {
1475         FREE(pstRowPath);
1476         FREE(pstColPath);
1477         FREE(pstDataPath);
1478         FREE(pstGroupName);
1479         return -1;
1480     }
1481
1482     status = H5Rcreate(&pDataRef[2], _iFile, pstDataPath, H5R_OBJECT, -1);
1483     if (status < 0)
1484     {
1485         FREE(pstRowPath);
1486         FREE(pstColPath);
1487         FREE(pstDataPath);
1488         FREE(pstGroupName);
1489         return -1;
1490     }
1491
1492     //FREE group names
1493     FREE(pstRowPath);
1494     FREE(pstColPath);
1495     FREE(pstDataPath);
1496     FREE(pstGroupName);
1497
1498     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1499     space = H5Screate_simple(1, dims, NULL);
1500     if (space < 0)
1501     {
1502         return -1;
1503     }
1504
1505     //Create the dataset and write the array data to it.
1506     iCompress = enableCompression(9, 1, dims);
1507     dset = H5Dcreate(_iFile, _pstDatasetName, H5T_STD_REF_OBJ, space, iCompress);
1508     if (dset < 0)
1509     {
1510         return -1;
1511     }
1512
1513     status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pDataRef);
1514     if (status < 0)
1515     {
1516         return -1;
1517     }
1518     //Add attribute SCILAB_Class = poly to dataset
1519     //sprintf(pstRow, "%d", _iRows);
1520     //sprintf(pstCol, "%d", _iCols);
1521     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_SPARSE);
1522     if (status < 0)
1523     {
1524         return -1;
1525     }
1526
1527     status = addIntAttribute(dset, g_SCILAB_CLASS_ROWS, _iRows);
1528     if (status < 0)
1529     {
1530         return -1;
1531     }
1532
1533     status = addIntAttribute(dset, g_SCILAB_CLASS_COLS, _iCols);
1534     if (status < 0)
1535     {
1536         return -1;
1537     }
1538
1539     status = addIntAttribute(dset, g_SCILAB_CLASS_ITEMS, _iNbItem);
1540     if (status < 0)
1541     {
1542         return -1;
1543     }
1544
1545     if (_iComplex)
1546     {
1547         //Add attribute Varname attribute to dataset
1548         status = addAttribute(dset, g_SCILAB_CLASS_COMPLEX, "true");
1549         if (status < 0)
1550         {
1551             return -1;
1552         }
1553     }
1554
1555     //Close and release resources.
1556     status = H5Dclose(dset);
1557     if (status < 0)
1558     {
1559         return -1;
1560     }
1561
1562     status = H5Sclose(space);
1563     if (status < 0)
1564     {
1565         return -1;
1566     }
1567
1568     return 0;
1569 }
1570
1571 int writeSparseMatrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow, int *_piColPos, double *_pdblReal)
1572 {
1573     return writeCommonSparseComplexMatrix(_iFile, _pstDatasetName, 0, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
1574 }
1575
1576 int writeSparseComplexMatrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow, int *_piColPos,
1577                              double *_pdblReal, double *_pdblImg)
1578 {
1579     return writeCommonSparseComplexMatrix(_iFile, _pstDatasetName, 1, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
1580 }
1581
1582 int writeBooleanSparseMatrix(int _iFile, char *_pstDatasetName, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow, int *_piColPos)
1583 {
1584     hsize_t dims[1] = { 2 };
1585     herr_t status = 0;
1586     hid_t space = 0;
1587     hid_t dset = 0;
1588     hid_t group = 0;
1589     hid_t iCompress = 0;
1590     hobj_ref_t pDataRef[2] = {0};
1591
1592     char *pstRowPath = NULL;
1593     char *pstColPath = NULL;
1594     char *pstGroupName = NULL;
1595
1596     // Generate groupname #<dataSetName>#
1597     pstGroupName = createGroupName(_pstDatasetName);
1598
1599     //First create a group to store all referenced objects.
1600     group = H5Gcreate(_iFile, pstGroupName, H5P_DEFAULT);
1601     status = H5Gclose(group);
1602     if (status < 0)
1603     {
1604         FREE(pstGroupName);
1605         return -1;
1606     }
1607
1608     //Create each sub dataset and insert data
1609     pstRowPath = createPathName(pstGroupName, 0);
1610     status = writeInteger32Matrix(_iFile, pstRowPath, 1, &_iRows, _piNbItemRow);
1611     if (status < 0)
1612     {
1613         FREE(pstRowPath);
1614         FREE(pstGroupName);
1615         return -1;
1616     }
1617
1618     status = H5Rcreate(&pDataRef[0], _iFile, pstRowPath, H5R_OBJECT, -1);
1619     if (status < 0)
1620     {
1621         FREE(pstRowPath);
1622         FREE(pstGroupName);
1623         return -1;
1624     }
1625
1626     pstColPath = createPathName(pstGroupName, 1);
1627     status = writeInteger32Matrix(_iFile, pstColPath, 1, &_iNbItem, _piColPos);
1628     if (status < 0)
1629     {
1630         FREE(pstRowPath);
1631         FREE(pstColPath);
1632         FREE(pstGroupName);
1633         return -1;
1634     }
1635
1636     status = H5Rcreate(&pDataRef[1], _iFile, pstColPath, H5R_OBJECT, -1);
1637     if (status < 0)
1638     {
1639         FREE(pstRowPath);
1640         FREE(pstColPath);
1641         FREE(pstGroupName);
1642         return -1;
1643     }
1644
1645     //FREE group names
1646     FREE(pstRowPath);
1647     FREE(pstColPath);
1648     FREE(pstGroupName);
1649
1650     //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1651     space = H5Screate_simple(1, dims, NULL);
1652     if (space < 0)
1653     {
1654         return -1;
1655     }
1656
1657     //Create the dataset and write the array data to it.
1658     iCompress = enableCompression(9, 1, dims);
1659     dset = H5Dcreate(_iFile, _pstDatasetName, H5T_STD_REF_OBJ, space, iCompress);
1660     if (dset < 0)
1661     {
1662         return -1;
1663     }
1664
1665     status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pDataRef);
1666     if (status < 0)
1667     {
1668         return -1;
1669     }
1670
1671     //Add attribute SCILAB_Class = boolean sparse to dataset
1672     status = addAttribute(dset, g_SCILAB_CLASS, g_SCILAB_CLASS_BSPARSE);
1673     if (status < 0)
1674     {
1675         return -1;
1676     }
1677
1678     status = addIntAttribute(dset, g_SCILAB_CLASS_ROWS, _iRows);
1679     if (status < 0)
1680     {
1681         return -1;
1682     }
1683
1684     status = addIntAttribute(dset, g_SCILAB_CLASS_COLS, _iCols);
1685     if (status < 0)
1686     {
1687         return -1;
1688     }
1689
1690     status = addIntAttribute(dset, g_SCILAB_CLASS_ITEMS, _iNbItem);
1691     if (status < 0)
1692     {
1693         return -1;
1694     }
1695     //Close and release resources.
1696     status = H5Dclose(dset);
1697     if (status < 0)
1698     {
1699         return -1;
1700     }
1701
1702     status = H5Sclose(space);
1703     if (status < 0)
1704     {
1705         return -1;
1706     }
1707
1708     return 0;
1709 }
1710
1711 //create a group and create hobj_ref_t array
1712 void *openList(int _iFile, char *pstDatasetName, int _iNbItem)
1713 {
1714     herr_t status = 0;
1715     hid_t group = 0;
1716     hobj_ref_t *pobjArray = NULL;
1717
1718     //First create a group to store all referenced objects.
1719     group = H5Gcreate(_iFile, pstDatasetName, H5P_DEFAULT);
1720     status = H5Gclose(group);
1721     if (status < 0)
1722     {
1723         return NULL;
1724     }
1725
1726     if (_iNbItem)
1727     {
1728         pobjArray = MALLOC(sizeof(hobj_ref_t) * _iNbItem);
1729     }
1730
1731     return pobjArray;
1732 }
1733
1734 int addItemInList(int _iFile, void *_pvList, int _iPos, char *_pstItemName)
1735 {
1736     hobj_ref_t *pobjArray = (hobj_ref_t *) _pvList;
1737
1738     return H5Rcreate(&pobjArray[_iPos], _iFile, _pstItemName, H5R_OBJECT, -1);
1739 }
1740
1741 int closeList(int _iFile, void *_pvList, char *_pstListName, int _iNbItem, int _iVarType)
1742 {
1743     herr_t status = 0;
1744     hsize_t dims[1] = { _iNbItem };
1745     hid_t space = 0;
1746     hid_t dset = 0;
1747     hid_t iCompress = 0;
1748     const char *pcstClass = NULL;
1749
1750     switch (_iVarType)
1751     {
1752         case sci_list:
1753             pcstClass = g_SCILAB_CLASS_LIST;
1754             break;
1755         case sci_tlist:
1756             pcstClass = g_SCILAB_CLASS_TLIST;
1757             break;
1758         case sci_mlist:
1759             pcstClass = g_SCILAB_CLASS_MLIST;
1760             break;
1761         default:
1762             return 1;
1763     }
1764
1765     if (_iNbItem == 0)
1766     {
1767         //tips for empty list
1768         //insert a fake refence in the array, value = 0
1769
1770         hobj_ref_t pvList[1];
1771
1772         pvList[0] = 0;
1773         //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1774
1775         dims[0] = 1;
1776         space = H5Screate_simple(1, dims, NULL);
1777         if (space < 0)
1778         {
1779             return -1;
1780         }
1781
1782         //Create the dataset and write the array data to it.
1783         iCompress = enableCompression(9, 1, dims);
1784         dset = H5Dcreate(_iFile, _pstListName, H5T_STD_REF_OBJ, space, iCompress);
1785         if (dset < 0)
1786         {
1787             return -1;
1788         }
1789
1790         status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, (hobj_ref_t *) pvList);
1791         if (status < 0)
1792         {
1793             return -1;
1794         }
1795
1796         //Add attribute SCILAB_Class = string to dataset
1797         status = addAttribute(dset, g_SCILAB_CLASS, pcstClass);
1798         if (status < 0)
1799         {
1800             return -1;
1801         }
1802
1803         status = addAttribute(dset, g_SCILAB_CLASS_EMPTY, "true");
1804         if (status < 0)
1805         {
1806             return -1;
1807         }
1808     }
1809     else
1810     {
1811         //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
1812         space = H5Screate_simple(1, dims, NULL);
1813         if (status < 0)
1814         {
1815             return -1;
1816         }
1817
1818         //Create the dataset and write the array data to it.
1819         iCompress = enableCompression(9, 1, dims);
1820         dset = H5Dcreate(_iFile, _pstListName, H5T_STD_REF_OBJ, space, iCompress);
1821         if (dset < 0)
1822         {
1823             return -1;
1824         }
1825
1826         status = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, (hobj_ref_t *) _pvList);
1827         if (status < 0)
1828         {
1829             return -1;
1830         }
1831
1832         //Add attribute SCILAB_Class = string to dataset
1833         status = addAttribute(dset, g_SCILAB_CLASS, pcstClass);
1834         if (status < 0)
1835         {
1836             return -1;
1837         }
1838
1839         status = addIntAttribute(dset, g_SCILAB_CLASS_ITEMS, _iNbItem);
1840         if (status < 0)
1841         {
1842             return -1;
1843         }
1844     }
1845
1846     //Close and release resources.
1847     status = H5Dclose(dset);
1848     if (status < 0)
1849     {
1850         return -1;
1851     }
1852
1853     status = H5Sclose(space);
1854     if (status < 0)
1855     {
1856         return -1;
1857     }
1858
1859     FREE(_pvList);
1860     return 0;
1861 }