SHOGUN  v3.2.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
SerializableHdf5File.cpp
Go to the documentation of this file.
00001 /*
00002  * This program is free software; you can redistribute it and/or modify
00003  * it under the terms of the GNU General Public License as published by
00004  * the Free Software Foundation; either version 3 of the License, or
00005  * (at your option) any later version.
00006  *
00007  * Written (W) 2010 Soeren Sonnenburg
00008  * Copyright (C) 2010 Berlin Institute of Technology
00009  */
00010 
00011 #include <shogun/lib/config.h>
00012 #ifdef HAVE_HDF5
00013 
00014 #include <shogun/io/SerializableHdf5File.h>
00015 #include <shogun/io/SerializableHdf5Reader00.h>
00016 
00017 #define NOT_OPEN                   ((hid_t) -1)
00018 
00019 #define STR_KEY_FILETYPE           "filetype"
00020 #define STR_FILETYPE_00 \
00021     "_SHOGUN_SERIALIZABLE_HDF5_FILE_V_00_"
00022 
00023 using namespace shogun;
00024 
00025 CSerializableHdf5File::type_item_t::type_item_t(const char* name_)
00026 {
00027     rank = 0;
00028     dims[0] = dims[1] = 0;
00029     dspace = dtype = dset = NOT_OPEN;
00030     vltype = NULL;
00031     y = x = sub_y = 0;
00032     sparse_ptr = NULL;
00033     name = name_;
00034 }
00035 
00036 CSerializableHdf5File::type_item_t::~type_item_t()
00037 {
00038     if (dset >= 0) H5Dclose(dset);
00039     if (dtype >= 0) H5Tclose(dtype);
00040     if (dspace >= 0) H5Sclose(dspace);
00041     if (vltype != NULL) SG_FREE(vltype);
00042     /* Do not delete SPARSE_PTR  */
00043 }
00044 
00045 hid_t
00046 CSerializableHdf5File::sizeof_sparsetype() {
00047     return H5Tget_size(TYPE_INDEX) + H5Tget_size(H5T_STD_REF_OBJ);
00048 }
00049 hid_t
00050 CSerializableHdf5File::new_sparsetype()
00051 {
00052     hid_t result = H5Tcreate(H5T_COMPOUND, sizeof_sparsetype());
00053 
00054     if (H5Tinsert(result, STR_SPARSE_FPTR, H5Tget_size(TYPE_INDEX),
00055                   H5T_STD_REF_OBJ) < 0)
00056         return NOT_OPEN;
00057 
00058     return result;
00059 }
00060 hobj_ref_t*
00061 CSerializableHdf5File::get_ref_sparstype(void* sparse_buf) {
00062     return (hobj_ref_t*)
00063         ((char*) sparse_buf + H5Tget_size(TYPE_INDEX));
00064 }
00065 
00066 hid_t
00067 CSerializableHdf5File::new_sparseentrytype(EPrimitiveType ptype)
00068 {
00069     hid_t result = H5Tcreate(H5T_COMPOUND,
00070                              TSGDataType::sizeof_sparseentry(ptype));
00071     if (result < 0) return NOT_OPEN;
00072 
00073     if (H5Tinsert(result, STR_SPARSEENTRY_FINDEX,
00074                   HOFFSET(SGSparseVectorEntry<char>, feat_index), TYPE_INDEX)
00075         < 0) return NOT_OPEN;
00076     if (H5Tinsert(result, STR_SPARSEENTRY_ENTRY, TSGDataType
00077                   ::offset_sparseentry(ptype),
00078                   ptype2hdf5(ptype)) < 0) return NOT_OPEN;
00079 
00080     return result;
00081 }
00082 
00083 hid_t
00084 CSerializableHdf5File::ptype2hdf5(EPrimitiveType ptype)
00085 {
00086     switch (ptype) {
00087     case PT_BOOL:
00088         switch (sizeof (bool)) {
00089         case 1: return H5T_NATIVE_UINT8;
00090         case 2: return H5T_NATIVE_UINT16;
00091         case 4: return H5T_NATIVE_UINT32;
00092         case 8: return H5T_NATIVE_UINT64;
00093         default: break;
00094         }
00095         break;
00096     case PT_CHAR: return H5T_NATIVE_CHAR; break;
00097     case PT_INT8: return H5T_NATIVE_INT8; break;
00098     case PT_UINT8: return H5T_NATIVE_UINT8; break;
00099     case PT_INT16: return H5T_NATIVE_INT16; break;
00100     case PT_UINT16: return H5T_NATIVE_UINT16; break;
00101     case PT_INT32: return H5T_NATIVE_INT32; break;
00102     case PT_UINT32: return H5T_NATIVE_UINT32; break;
00103     case PT_INT64: return H5T_NATIVE_INT64; break;
00104     case PT_UINT64: return H5T_NATIVE_UINT64; break;
00105     case PT_FLOAT32: return H5T_NATIVE_FLOAT; break;
00106     case PT_FLOAT64: return H5T_NATIVE_DOUBLE; break;
00107     case PT_FLOATMAX: return H5T_NATIVE_LDOUBLE; break;
00108     case PT_COMPLEX128: return NOT_OPEN; break;
00109     case PT_SGOBJECT: return NOT_OPEN; break;
00110     case PT_UNDEFINED:
00111         SG_SERROR("Type undefined\n");
00112         return NOT_OPEN;
00113     }
00114 
00115     return NOT_OPEN;
00116 }
00117 
00118 hid_t
00119 CSerializableHdf5File::new_stype2hdf5(EStructType stype,
00120                                       EPrimitiveType ptype)
00121 {
00122     hid_t result = ptype2hdf5(ptype);
00123 
00124     switch (stype) {
00125     case ST_NONE: result = H5Tcopy(result); break;
00126     case ST_STRING: result = H5Tvlen_create(result); break;
00127     case ST_SPARSE: result = new_sparsetype(); break;
00128     default: break;
00129     }
00130 
00131     return result;
00132 }
00133 
00134 bool
00135 CSerializableHdf5File::index2string(
00136     char* dest, size_t n, EContainerType ctype, index_t y, index_t x)
00137 {
00138     switch (ctype) {
00139     case CT_NDARRAY: SG_SNOTIMPLEMENTED
00140     case CT_SCALAR: return false;
00141     case CT_VECTOR: case CT_SGVECTOR: snprintf(dest, n, "y%u", y); break;
00142     case CT_MATRIX: case CT_SGMATRIX: snprintf(dest, n, "y%u_x%u", y, x); break;
00143     default: return false;
00144     }
00145 
00146     return true;
00147 }
00148 
00149 bool
00150 CSerializableHdf5File::isequal_stype2hdf5(EStructType stype,
00151                                           EPrimitiveType ptype,
00152                                           hid_t htype)
00153 {
00154     hid_t pbuf = ptype2hdf5(ptype), pbuf2 = NOT_OPEN;
00155 
00156     bool to_close = false;
00157     switch (stype) {
00158     case ST_UNDEFINED:
00159     case ST_NONE: break;
00160     case ST_STRING:
00161         to_close = true; pbuf = H5Tvlen_create(pbuf); break;
00162     case ST_SPARSE:
00163         to_close = true; pbuf = new_sparsetype();
00164         pbuf2 = new_sparseentrytype(ptype); break;
00165     }
00166 
00167     bool result = (H5Tequal(htype, pbuf) > 0)
00168         || (pbuf2 >= 0 && H5Tequal(htype, pbuf2) > 0);
00169 
00170     if (pbuf2 >= 0 && H5Tclose(pbuf2) < 0) return false;
00171     if (to_close && H5Tclose(pbuf) < 0) return false;
00172     return result;
00173 }
00174 
00175 bool
00176 CSerializableHdf5File::dspace_select(EContainerType ctype, index_t y,
00177                                      index_t x)
00178 {
00179     type_item_t* m = m_stack_type.back();
00180 
00181     if (H5Sselect_none(m->dspace) < 0) return false;
00182 
00183     hsize_t coord[2];
00184     switch (ctype) {
00185     case CT_NDARRAY: SG_NOTIMPLEMENTED
00186     case CT_SCALAR: return false;
00187     case CT_MATRIX: case CT_SGMATRIX: coord[1] = x; /* break;  */
00188     case CT_VECTOR: case CT_SGVECTOR: coord[0] = y; break;
00189     default: return false;
00190     }
00191     if (H5Sselect_elements(m->dspace, H5S_SELECT_SET, 1, coord) < 0)
00192         return false;
00193 
00194     return true;
00195 }
00196 
00197 bool
00198 CSerializableHdf5File::attr_write_scalar(
00199     hid_t datatype, const char* name, const void* val)
00200 {
00201     hid_t dspace;
00202     if ((dspace = H5Screate_simple(0, NULL, NULL)) < 0) return false;
00203     hid_t dtype;
00204     if ((dtype = H5Tcopy(datatype)) < 0) return false;
00205     hid_t attr;
00206     if ((attr = H5Acreate2(
00207              m_stack_h5stream.back(), name, dtype, dspace,
00208              H5P_DEFAULT, H5P_DEFAULT)) < 0) return false;
00209 
00210     if (H5Awrite(attr, datatype, val) < 0) return false;
00211 
00212     if (H5Aclose(attr) < 0) return false;
00213     if (H5Tclose(dtype) < 0) return false;
00214     if (H5Sclose(dspace) < 0) return false;
00215 
00216     return true;
00217 }
00218 
00219 bool
00220 CSerializableHdf5File::attr_write_string(
00221     const char* name, const char* val)
00222 {
00223     hid_t dtype;
00224     if ((dtype = H5Tcopy(H5T_C_S1)) < 0) return false;
00225     if (H5Tset_size(dtype, strlen(val)+1) < 0) return false;
00226 
00227     if (!attr_write_scalar(dtype, name, val)) return false;
00228 
00229     if (H5Tclose(dtype) < 0) return false;
00230 
00231     return true;
00232 }
00233 
00234 bool
00235 CSerializableHdf5File::attr_exists(const char* name)
00236 {
00237     return H5Aexists(m_stack_h5stream.back(), name) > 0;
00238 }
00239 
00240 size_t
00241 CSerializableHdf5File::attr_get_size(const char* name)
00242 {
00243     if (!attr_exists(name)) return 0;
00244 
00245     hid_t attr;
00246     if ((attr = H5Aopen(m_stack_h5stream.back(), name, H5P_DEFAULT))
00247         < 0) return 0;
00248 
00249     hid_t dtype;
00250     if ((dtype = H5Aget_type(attr)) < 0) return 0;
00251 
00252     size_t result = H5Tget_size(dtype);
00253 
00254     if (H5Tclose(dtype) < 0) return 0;
00255     if (H5Aclose(attr) < 0) return 0;
00256 
00257     return result;
00258 }
00259 
00260 bool
00261 CSerializableHdf5File::attr_read_scalar(
00262     hid_t datatype, const char* name, void* val)
00263 {
00264     if (!attr_exists(name)) return false;
00265 
00266     hid_t attr;
00267     if ((attr = H5Aopen(m_stack_h5stream.back(), name, H5P_DEFAULT))
00268         < 0) return false;
00269 
00270     hid_t dspace;
00271     if ((dspace = H5Aget_space(attr)) < 0) return false;
00272     if (H5Sget_simple_extent_type(dspace) != H5S_SCALAR) return false;
00273 
00274     hid_t dtype;
00275     if ((dtype = H5Aget_type(attr)) < 0) return false;
00276     if (H5Tequal(datatype, dtype) <= 0) return false;
00277 
00278     if (H5Aread(attr, datatype, val) < 0) return false;
00279 
00280     if (H5Tclose(dtype) < 0) return false;
00281     if (H5Sclose(dspace) < 0) return false;
00282     if (H5Aclose(attr) < 0) return false;
00283 
00284     return true;
00285 }
00286 
00287 bool
00288 CSerializableHdf5File::attr_read_string(
00289     const char* name, char* val, size_t n)
00290 {
00291     size_t size = attr_get_size(name);
00292     if (size == 0 || size > n) return false;
00293 
00294     hid_t dtype;
00295     if ((dtype = H5Tcopy(H5T_C_S1)) < 0) return false;
00296     if (H5Tset_size(dtype, size) < 0) return false;
00297 
00298     if (!attr_read_scalar(dtype, name, val)) return false;
00299 
00300     if (H5Tclose(dtype) < 0) return false;
00301 
00302     return true;
00303 }
00304 
00305 bool
00306 CSerializableHdf5File::group_create(const char* name,
00307                                     const char* prefix)
00308 {
00309     hid_t ngroup;
00310     string_t gname;
00311 
00312     snprintf(gname, STRING_LEN, "%s%s", prefix, name);
00313 
00314     m_stack_h5stream.push_back(
00315         ngroup = H5Gcreate2(m_stack_h5stream.back(), gname, H5P_DEFAULT,
00316                             H5P_DEFAULT, H5P_DEFAULT));
00317     if (ngroup < 0) return false;
00318 
00319     return true;
00320 }
00321 
00322 bool
00323 CSerializableHdf5File::group_open(const char* name,
00324                                   const char* prefix)
00325 {
00326     hid_t group;
00327     string_t gname;
00328 
00329     snprintf(gname, STRING_LEN, "%s%s", prefix, name);
00330 
00331     m_stack_h5stream.push_back(
00332         group = H5Gopen2(m_stack_h5stream.back(), gname, H5P_DEFAULT));
00333     if (group < 0) return false;
00334 
00335     return true;
00336 }
00337 
00338 bool
00339 CSerializableHdf5File::group_close()
00340 {
00341     if (H5Gclose(m_stack_h5stream.back()) < 0) return false;
00342     m_stack_h5stream.pop_back();
00343 
00344     return true;
00345 }
00346 
00347 CSerializableHdf5File::CSerializableHdf5File()
00348     :CSerializableFile() { init(""); }
00349 
00350 CSerializableHdf5File::CSerializableHdf5File(const char* fname, char rw)
00351     :CSerializableFile()
00352 {
00353     CSerializableFile::init(NULL, rw, fname);
00354     init(fname);
00355 }
00356 
00357 CSerializableHdf5File::~CSerializableHdf5File()
00358 {
00359     while (m_stack_type.get_num_elements() > 0) {
00360         delete m_stack_type.back(); m_stack_type.pop_back();
00361     }
00362 
00363     close();
00364 }
00365 
00366 CSerializableFile::TSerializableReader*
00367 CSerializableHdf5File::new_reader(char* dest_version, size_t n)
00368 {
00369     if (!attr_read_string(STR_KEY_FILETYPE, dest_version, n))
00370         return NULL;
00371 
00372     if (strcmp(STR_FILETYPE_00, dest_version) == 0)
00373         return new SerializableHdf5Reader00(this);
00374 
00375     return NULL;
00376 }
00377 
00378 void
00379 CSerializableHdf5File::init(const char* fname)
00380 {
00381     if (m_filename == NULL || *m_filename == '\0') {
00382         SG_WARNING("Filename not given for opening file!\n")
00383         close(); return;
00384     }
00385 
00386     hid_t h5stream = NOT_OPEN;
00387     switch (m_task) {
00388     case 'w':
00389         h5stream = H5Fcreate(fname, H5F_ACC_TRUNC, H5P_DEFAULT,
00390                              H5P_DEFAULT);
00391         break;
00392     case 'r':
00393         h5stream = H5Fopen(fname, H5F_ACC_RDONLY, H5P_DEFAULT);
00394         break;
00395     default:
00396         SG_WARNING("Could not open file `%s', unknown mode!\n",
00397                    m_filename);
00398         close(); return;
00399     }
00400 
00401     if (h5stream < 0) {
00402         SG_WARNING("Could not open file `%s'!\n", m_filename)
00403         close(); return;
00404     }
00405 
00406     m_stack_h5stream.push_back(h5stream);
00407     switch (m_task) {
00408     case 'w':
00409         if (!attr_write_string(STR_KEY_FILETYPE, STR_FILETYPE_00)) {
00410             SG_WARNING("%s: Could not open file for writing during "
00411                        "writing filetype!\n", fname);
00412             close(); return;
00413         }
00414         break;
00415     case 'r': break;
00416     default: break;
00417     }
00418 }
00419 
00420 void
00421 CSerializableHdf5File::close()
00422 {
00423     while (m_stack_h5stream.get_num_elements() > 1) {
00424         if (m_stack_h5stream.back() >= 0)
00425             H5Gclose(m_stack_h5stream.back());
00426         m_stack_h5stream.pop_back();
00427     }
00428 
00429     if (m_stack_h5stream.get_num_elements() == 1) {
00430         if (m_stack_h5stream.back() >= 0)
00431             H5Fclose(m_stack_h5stream.back());
00432         m_stack_h5stream.pop_back();
00433     }
00434 }
00435 
00436 bool
00437 CSerializableHdf5File::is_opened()
00438 {
00439     return m_stack_h5stream.get_num_elements() > 0;
00440 }
00441 
00442 bool
00443 CSerializableHdf5File::write_scalar_wrapped(
00444     const TSGDataType* type, const void* param)
00445 {
00446     type_item_t* m = m_stack_type.back();
00447 
00448     switch (type->m_stype) {
00449     case ST_NONE:
00450         if (m->y != 0 || m->x != 0) return true;
00451         break;
00452     case ST_STRING:
00453         if (m->sub_y == 0)
00454             m->vltype[m->x*m->dims[1] + m->y].p = (void*) param;
00455 
00456         if ((m->sub_y
00457              < (index_t) m->vltype[m->x*m->dims[1] + m->y].len-1)
00458             || ((type->m_ctype == CT_VECTOR || type->m_ctype == CT_SGVECTOR) && m->y
00459                 < (index_t) m->dims[0]-1)
00460             || ((type->m_ctype == CT_MATRIX || type->m_ctype==CT_SGMATRIX)
00461                 && (m->x < (index_t) m->dims[0]-1
00462                     || m->y < (index_t) m->dims[1]-1)))
00463             return true;
00464         break;
00465     case ST_SPARSE:
00466         if (m->sub_y != 0) return true;
00467         break;
00468     default: return false;
00469     }
00470 
00471     hid_t mem_type_id;
00472     if ((mem_type_id = new_stype2hdf5(type->m_stype, type->m_ptype)
00473             ) < 0) return false;
00474 
00475     switch (type->m_stype) {
00476     case ST_NONE:
00477         if (H5Dwrite(m->dset, mem_type_id, H5S_ALL, H5S_ALL,
00478                      H5P_DEFAULT, param) < 0) return false;
00479         break;
00480     case ST_STRING:
00481         if (H5Dwrite(m->dset, mem_type_id, H5S_ALL, H5S_ALL,
00482                      H5P_DEFAULT, m->vltype) < 0) return false;
00483         break;
00484     case ST_SPARSE:
00485         if (H5Dwrite(m->dset, m->dtype, H5S_ALL, H5S_ALL,
00486                      H5P_DEFAULT, m->sparse_ptr) < 0) return false;
00487         break;
00488     default: return false;
00489     }
00490 
00491     if (H5Tclose(mem_type_id) < 0) return false;
00492 
00493     return true;
00494 }
00495 
00496 bool
00497 CSerializableHdf5File::write_cont_begin_wrapped(
00498     const TSGDataType* type, index_t len_real_y, index_t len_real_x)
00499 {
00500     hbool_t bool_buf = true;
00501 
00502     if (type->m_ptype != PT_SGOBJECT) return true;
00503 
00504     if (!attr_write_scalar(H5T_NATIVE_HBOOL, STR_IS_CONT, &bool_buf))
00505         return false;
00506 
00507     string_t ctype_buf;
00508     type->to_string(ctype_buf, STRING_LEN);
00509     if (!attr_write_string(STR_CTYPE_NAME, ctype_buf)) return false;
00510 
00511     switch (type->m_ctype) {
00512     case CT_NDARRAY:
00513         SG_NOTIMPLEMENTED
00514     case CT_SCALAR:
00515         SG_ERROR("write_cont_begin_wrapped(): Implementation error "
00516                  "during writing Hdf5File!");
00517         return false;
00518     case CT_MATRIX: case CT_SGMATRIX:
00519         if (!attr_write_scalar(TYPE_INDEX, STR_LENGTH_X, &len_real_x))
00520             return false;
00521         /* break;  */
00522     case CT_VECTOR: case CT_SGVECTOR:
00523         if (!attr_write_scalar(TYPE_INDEX, STR_LENGTH_Y, &len_real_y))
00524             return false;
00525         break;
00526     default: return false;
00527     }
00528 
00529     return true;
00530 }
00531 
00532 bool
00533 CSerializableHdf5File::write_cont_end_wrapped(
00534     const TSGDataType* type, index_t len_real_y, index_t len_real_x)
00535 {
00536     return true;
00537 }
00538 
00539 bool
00540 CSerializableHdf5File::write_string_begin_wrapped(
00541     const TSGDataType* type, index_t length)
00542 {
00543     type_item_t* m = m_stack_type.back();
00544 
00545     m->vltype[m->x*m->dims[1] + m->y].len = length;
00546 
00547     return true;
00548 }
00549 
00550 bool
00551 CSerializableHdf5File::write_string_end_wrapped(
00552     const TSGDataType* type, index_t length)
00553 {
00554     return true;
00555 }
00556 
00557 bool
00558 CSerializableHdf5File::write_stringentry_begin_wrapped(
00559     const TSGDataType* type, index_t y)
00560 {
00561     type_item_t* m = m_stack_type.back();
00562 
00563     m->sub_y = y;
00564 
00565     return true;
00566 }
00567 
00568 bool
00569 CSerializableHdf5File::write_stringentry_end_wrapped(
00570     const TSGDataType* type, index_t y)
00571 {
00572     return true;
00573 }
00574 
00575 bool
00576 CSerializableHdf5File::write_sparse_begin_wrapped(
00577     const TSGDataType* type, index_t length)
00578 {
00579     type_item_t* m_prev = m_stack_type.back();
00580 
00581     if(!dspace_select(type->m_ctype, m_prev->y, m_prev->x))
00582         return false;
00583 
00584     type_item_t* m = new type_item_t(m_stack_type.back()->name);
00585     m_stack_type.push_back(m);
00586 
00587     /* ************************************************************ */
00588 
00589     if (m_prev->y == 0 && m_prev->x == 0) {
00590         hbool_t bool_buf = true;
00591         if (!group_create(m->name, STR_GROUP_PREFIX)) return false;
00592 
00593         if (!attr_write_scalar(H5T_NATIVE_HBOOL, STR_IS_SPARSE,
00594                                &bool_buf)) return false;
00595     } else {
00596         if (!group_open(m->name, STR_GROUP_PREFIX)) return false;
00597         if (!attr_exists(STR_IS_SPARSE)) return false;
00598     }
00599 
00600     m->rank = 1; m->dims[0] = length;
00601     if (m->dims[0] == 0) m->dspace = H5Screate(H5S_NULL);
00602 
00603     if (m->dspace < 0 && (m->dspace = H5Screate_simple(
00604                               m->rank, m->dims, NULL)) < 0)
00605         return false;
00606     if ((m->dtype = new_sparseentrytype(type->m_ptype)) < 0)
00607         return false;
00608 
00609     string_t name;
00610     index2string(name, STRING_LEN, type->m_ctype, m_prev->y,
00611                  m_prev->x);
00612     if ((m->dset = H5Dcreate2(
00613              m_stack_h5stream.back(), name, m->dtype, m->dspace,
00614              H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
00615         return false;
00616 
00617     /* ************************************************************ */
00618 
00619     char* buf = SG_MALLOC(char, sizeof_sparsetype());
00620 
00621     hid_t mem_type_id;
00622     if ((mem_type_id = new_sparsetype()) < 0) return false;
00623 
00624     hid_t mem_space_id;
00625     if ((mem_space_id = H5Screate_simple(0, NULL, NULL)) < 0)
00626         return false;
00627 
00628     hobj_ref_t* sparse_ref = get_ref_sparstype(buf);
00629     if (H5Rcreate(sparse_ref, m_stack_h5stream.back(), name,
00630                   H5R_OBJECT, -1) < 0) return false;
00631 
00632     if (H5Dwrite(m_prev->dset, mem_type_id, mem_space_id,
00633                  m_prev->dspace, H5P_DEFAULT, buf) < 0) return false;
00634 
00635     if (H5Sclose(mem_space_id) < 0) return false;
00636     if (H5Tclose(mem_type_id) < 0) return false;
00637 
00638     delete buf;
00639 
00640     return true;
00641 }
00642 
00643 bool
00644 CSerializableHdf5File::write_sparse_end_wrapped(
00645     const TSGDataType* type, index_t length)
00646 {
00647     if (!group_close()) return false;
00648     delete m_stack_type.back(); m_stack_type.pop_back();
00649 
00650     return true;
00651 }
00652 
00653 bool
00654 CSerializableHdf5File::write_sparseentry_begin_wrapped(
00655     const TSGDataType* type, const SGSparseVectorEntry<char>* first_entry,
00656     index_t feat_index, index_t y)
00657 {
00658     type_item_t* m = m_stack_type.back();
00659 
00660     m->sparse_ptr = (SGSparseVectorEntry<char>*) first_entry;
00661     m->sub_y = y;
00662 
00663     return true;
00664 }
00665 
00666 bool
00667 CSerializableHdf5File::write_sparseentry_end_wrapped(
00668     const TSGDataType* type, const SGSparseVectorEntry<char>* first_entry,
00669     index_t feat_index, index_t y)
00670 {
00671     return true;
00672 }
00673 
00674 bool
00675 CSerializableHdf5File::write_item_begin_wrapped(
00676     const TSGDataType* type, index_t y, index_t x)
00677 {
00678     type_item_t* m = m_stack_type.back();
00679     m->y = y; m->x = x;
00680 
00681     if (type->m_ptype != PT_SGOBJECT) return true;
00682 
00683     string_t name;
00684     if (!index2string(name, STRING_LEN, type->m_ctype, y, x))
00685         return false;
00686     if (!group_create(name, "")) return false;
00687 
00688     return true;
00689 }
00690 
00691 bool
00692 CSerializableHdf5File::write_item_end_wrapped(
00693     const TSGDataType* type, index_t y, index_t x)
00694 {
00695     if (type->m_ptype == PT_SGOBJECT)
00696         if (!group_close()) return false;
00697 
00698     return true;
00699 }
00700 
00701 bool
00702 CSerializableHdf5File::write_sgserializable_begin_wrapped(
00703     const TSGDataType* type, const char* sgserializable_name,
00704     EPrimitiveType generic)
00705 {
00706     hbool_t bool_buf = true;
00707 
00708     if (!attr_write_scalar(H5T_NATIVE_HBOOL, STR_IS_SGSERIALIZABLE,
00709                            &bool_buf)) return false;
00710 
00711     if (*sgserializable_name == '\0') {
00712         if (!attr_write_scalar(H5T_NATIVE_HBOOL, STR_IS_NULL,
00713                                &bool_buf))
00714             return false;
00715         return true;
00716     }
00717 
00718     if (!attr_write_string(STR_INSTANCE_NAME, sgserializable_name))
00719         return false;
00720 
00721     if (generic != PT_NOT_GENERIC) {
00722         string_t buf;
00723         TSGDataType::ptype_to_string(buf, generic, STRING_LEN);
00724         if (!attr_write_string(STR_GENERIC_NAME, buf)) return false;
00725     }
00726 
00727     return true;
00728 }
00729 
00730 bool
00731 CSerializableHdf5File::write_sgserializable_end_wrapped(
00732     const TSGDataType* type, const char* sgserializable_name,
00733     EPrimitiveType generic)
00734 {
00735     return true;
00736 }
00737 
00738 bool
00739 CSerializableHdf5File::write_type_begin_wrapped(
00740     const TSGDataType* type, const char* name, const char* prefix)
00741 {
00742     type_item_t* m = new type_item_t(name); m_stack_type.push_back(m);
00743 
00744     if (type->m_ptype == PT_SGOBJECT) {
00745         if (!group_create(name, "")) return false;
00746         return true;
00747     }
00748 
00749     switch (type->m_ctype) {
00750     case CT_NDARRAY:
00751         SG_NOTIMPLEMENTED
00752     case CT_SCALAR:
00753         m->rank = 0;
00754         if (type->m_stype == ST_STRING) m->vltype = SG_MALLOC(hvl_t, 1);
00755         break;
00756     case CT_VECTOR: case CT_SGVECTOR:
00757         m->rank = 1; m->dims[0] = *type->m_length_y;
00758         if (m->dims[0] == 0) m->dspace = H5Screate(H5S_NULL);
00759         if (type->m_stype == ST_STRING)
00760             m->vltype = SG_MALLOC(hvl_t, m->dims[0]);
00761         break;
00762     case CT_MATRIX: case CT_SGMATRIX:
00763         m->rank = 2;
00764         m->dims[0] = *type->m_length_x; m->dims[1] = *type->m_length_y;
00765         if (m->dims[0] *m->dims[1] == 0)
00766             m->dspace = H5Screate(H5S_NULL);
00767         if (type->m_stype == ST_STRING)
00768             m->vltype = SG_MALLOC(hvl_t, m->dims[0] *m->dims[1]);
00769         break;
00770     default: return false;
00771     }
00772 
00773     if (m->dspace < 0 && (m->dspace = H5Screate_simple(
00774                               m->rank, m->dims, NULL)) < 0)
00775         return false;
00776     if ((m->dtype = new_stype2hdf5(type->m_stype, type->m_ptype)) < 0)
00777         return false;
00778 
00779     if ((m->dset = H5Dcreate2(
00780              m_stack_h5stream.back(), name, m->dtype, m->dspace,
00781              H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
00782         return false;
00783 
00784     return true;
00785 }
00786 
00787 bool
00788 CSerializableHdf5File::write_type_end_wrapped(
00789     const TSGDataType* type, const char* name, const char* prefix)
00790 {
00791     if (type->m_ptype == PT_SGOBJECT)
00792         if (!group_close()) return false;
00793 
00794     delete m_stack_type.back(); m_stack_type.pop_back();
00795     return true;
00796 }
00797 
00798 #endif /* HAVE_HDF5  */
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

SHOGUN Machine Learning Toolbox - Documentation