00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011 #include "lib/config.h"
00012 #ifdef HAVE_HDF5
00013
00014 #include "lib/SerializableHdf5Reader00.h"
00015
00016 using namespace shogun;
00017
00018 SerializableHdf5Reader00::SerializableHdf5Reader00(
00019 CSerializableHdf5File* file) { m_file = file; }
00020
00021 SerializableHdf5Reader00::~SerializableHdf5Reader00(void) {}
00022
00023 bool
00024 SerializableHdf5Reader00::read_scalar_wrapped(
00025 const TSGDataType* type, void* param)
00026 {
00027 CSerializableHdf5File::type_item_t* m
00028 = m_file->m_stack_type.back();
00029
00030 switch (type->m_stype) {
00031 case ST_NONE:
00032 if (m->y != 0 || m->x != 0) return true;
00033 break;
00034 case ST_STRING:
00035 if (m->y == -1 || m->x == -1) break;
00036
00037 if (m->sub_y != 0) return true;
00038
00039 memcpy(param, m->vltype[m->x*m->dims[1] + m->y].p,
00040 m->vltype[m->x*m->dims[1] + m->y].len
00041 *type->sizeof_ptype());
00042
00043 return true;
00044 case ST_SPARSE:
00045 if (m->sub_y != 0) return true;
00046 break;
00047 }
00048
00049 hid_t mem_type_id;
00050 if ((mem_type_id = CSerializableHdf5File::new_stype2hdf5(
00051 type->m_stype, type->m_ptype)) < 0) return false;
00052
00053 switch (type->m_stype) {
00054 case ST_NONE:
00055 if (H5Dread(m->dset, mem_type_id, H5S_ALL, H5S_ALL,
00056 H5P_DEFAULT, param) < 0) return false;
00057 break;
00058 case ST_STRING:
00059 if (H5Dread(m->dset, mem_type_id, H5S_ALL, H5S_ALL,
00060 H5P_DEFAULT, m->vltype) < 0) return false;
00061 break;
00062 case ST_SPARSE:
00063 if (H5Dread(m->dset, m->dtype, H5S_ALL, H5S_ALL,
00064 H5P_DEFAULT, m->sparse_ptr) < 0) return false;
00065 break;
00066 }
00067
00068 if (H5Tclose(mem_type_id) < 0) return false;
00069
00070 return true;
00071 }
00072
00073 bool
00074 SerializableHdf5Reader00::read_cont_begin_wrapped(
00075 const TSGDataType* type, index_t* len_read_y, index_t* len_read_x)
00076 {
00077 CSerializableHdf5File::type_item_t* m
00078 = m_file->m_stack_type.back();
00079
00080 if (type->m_ptype != PT_SGOBJECT) {
00081 switch (type->m_ctype) {
00082 case CT_SCALAR:
00083 SG_ERROR("read_cont_begin_wrapped(): Implementation error"
00084 " during writing Hdf5File (0)!");
00085 return false;
00086 case CT_VECTOR: *len_read_y = m->dims[0]; break;
00087 case CT_MATRIX:
00088 *len_read_x = m->dims[0]; *len_read_y = m->dims[1];
00089 break;
00090 }
00091
00092 return true;
00093 }
00094
00095 if (!m_file->attr_exists(STR_IS_CONT)) return false;
00096
00097 string_t ctype_buf, buf;
00098 type->to_string(ctype_buf, STRING_LEN);
00099 if (!m_file->attr_read_string(STR_CTYPE_NAME, buf, STRING_LEN))
00100 return false;
00101 if (strcmp(ctype_buf, buf) != 0) return false;
00102
00103 switch (type->m_ctype) {
00104 case CT_SCALAR:
00105 SG_ERROR("read_cont_begin_wrapped(): Implementation error"
00106 " during writing Hdf5File (1)!");
00107 return false;
00108 case CT_MATRIX:
00109 if (!m_file->attr_read_scalar(TYPE_INDEX, STR_LENGTH_X,
00110 len_read_x))
00111 return false;
00112
00113 case CT_VECTOR:
00114 if (!m_file->attr_read_scalar(TYPE_INDEX, STR_LENGTH_Y,
00115 len_read_y))
00116 return false;
00117 break;
00118 }
00119
00120 return true;
00121 }
00122
00123 bool
00124 SerializableHdf5Reader00::read_cont_end_wrapped(
00125 const TSGDataType* type, index_t len_read_y, index_t len_read_x)
00126 {
00127 return true;
00128 }
00129
00130 bool
00131 SerializableHdf5Reader00::read_string_begin_wrapped(
00132 const TSGDataType* type, index_t* length)
00133 {
00134 CSerializableHdf5File::type_item_t* m
00135 = m_file->m_stack_type.back();
00136
00137 if (m->y == 0 && m->x == 0) {
00138 m->y = -1; m->x = -1;
00139 read_scalar_wrapped(type, NULL);
00140 m->y = 0; m->x = 0;
00141 }
00142
00143 *length = m->vltype[m->x*m->dims[1] + m->y].len;
00144
00145 return true;
00146 }
00147
00148 bool
00149 SerializableHdf5Reader00::read_string_end_wrapped(
00150 const TSGDataType* type, index_t length)
00151 {
00152 return true;
00153 }
00154
00155 bool
00156 SerializableHdf5Reader00::read_stringentry_begin_wrapped(
00157 const TSGDataType* type, index_t y)
00158 {
00159 CSerializableHdf5File::type_item_t* m
00160 = m_file->m_stack_type.back();
00161
00162 m->sub_y = y;
00163
00164 return true;
00165 }
00166
00167 bool
00168 SerializableHdf5Reader00::read_stringentry_end_wrapped(
00169 const TSGDataType* type, index_t y)
00170 {
00171 return true;
00172 }
00173
00174 bool
00175 SerializableHdf5Reader00::read_sparse_begin_wrapped(
00176 const TSGDataType* type, index_t* vec_index,
00177 index_t* length)
00178 {
00179 CSerializableHdf5File::type_item_t* m_prev
00180 = m_file->m_stack_type.back();
00181
00182 if(!m_file->dspace_select(type->m_ctype, m_prev->y, m_prev->x))
00183 return false;
00184
00185 CSerializableHdf5File::type_item_t* m = new CSerializableHdf5File
00186 ::type_item_t(m_prev->name);
00187 m_file->m_stack_type.push_back(m);
00188
00189
00190
00191 if (!m_file->group_open(m->name, STR_GROUP_PREFIX)) return false;
00192 if (!m_file->attr_exists(STR_IS_SPARSE)) return false;
00193
00194 string_t name;
00195 CSerializableHdf5File::index2string(
00196 name, STRING_LEN, type->m_ctype, m_prev->y, m_prev->x);
00197 if ((m->dset = H5Dopen2(m_file->m_stack_h5stream.back(), name,
00198 H5P_DEFAULT)) < 0)
00199 return false;
00200
00201 if ((m->dtype = H5Dget_type(m->dset)) < 0) return false;
00202 if (!CSerializableHdf5File::isequal_stype2hdf5(
00203 type->m_stype, type->m_ptype, m->dtype)) return false;
00204
00205 if ((m->dspace = H5Dget_space(m->dset)) < 0) return false;
00206 if (H5Sget_simple_extent_ndims(m->dspace) != 1) return false;
00207
00208
00209 if ((m->rank = H5Sget_simple_extent_dims(m->dspace, m->dims, NULL)
00210 ) < 0) return false;
00211
00212 if (H5Sget_simple_extent_type(m->dspace) != H5S_NULL
00213 && m->rank != 1) return false;
00214
00215 *length = m->dims[0];
00216
00217
00218
00219 char* buf = new char[CSerializableHdf5File::sizeof_sparsetype()];
00220
00221 hid_t mem_type_id;
00222 if ((mem_type_id = CSerializableHdf5File::new_sparsetype()) < 0)
00223 return false;
00224
00225 hid_t mem_space_id;
00226 if ((mem_space_id = H5Screate_simple(0, NULL, NULL)) < 0)
00227 return false;
00228
00229 if (H5Dread(m_prev->dset, mem_type_id, mem_space_id,
00230 m_prev->dspace, H5P_DEFAULT, buf) < 0) return false;
00231
00232 if (H5Sclose(mem_space_id) < 0) return false;
00233 if (H5Tclose(mem_type_id) < 0) return false;
00234
00235 *vec_index = *(index_t*) buf;
00236
00237 delete buf;
00238
00239 return true;
00240 }
00241
00242 bool
00243 SerializableHdf5Reader00::read_sparse_end_wrapped(
00244 const TSGDataType* type, index_t* vec_index,
00245 index_t length)
00246 {
00247 if (!m_file->group_close()) return false;
00248
00249 delete m_file->m_stack_type.back();
00250 m_file->m_stack_type.pop_back();
00251
00252 return true;
00253 }
00254
00255 bool
00256 SerializableHdf5Reader00::read_sparseentry_begin_wrapped(
00257 const TSGDataType* type, TSparseEntry<char>* first_entry,
00258 index_t* feat_index, index_t y)
00259 {
00260 CSerializableHdf5File::type_item_t* m
00261 = m_file->m_stack_type.back();
00262
00263 m->sparse_ptr = first_entry;
00264 m->sub_y = y;
00265
00266 return true;
00267 }
00268
00269 bool
00270 SerializableHdf5Reader00::read_sparseentry_end_wrapped(
00271 const TSGDataType* type, TSparseEntry<char>* first_entry,
00272 index_t* feat_index, index_t y)
00273 {
00274 return true;
00275 }
00276
00277 bool
00278 SerializableHdf5Reader00::read_item_begin_wrapped(
00279 const TSGDataType* type, index_t y, index_t x)
00280 {
00281 CSerializableHdf5File::type_item_t* m
00282 = m_file->m_stack_type.back();
00283 m->y = y; m->x = x;
00284
00285 if (type->m_ptype != PT_SGOBJECT) return true;
00286
00287 string_t name;
00288 if (!CSerializableHdf5File::index2string(
00289 name, STRING_LEN, type->m_ctype, y, x)) return false;
00290 if (!m_file->group_open(name, "")) return false;
00291
00292 return true;
00293 }
00294
00295 bool
00296 SerializableHdf5Reader00::read_item_end_wrapped(
00297 const TSGDataType* type, index_t y, index_t x)
00298 {
00299 if (type->m_ptype == PT_SGOBJECT)
00300 if (!m_file->group_close()) return false;
00301
00302 return true;
00303 }
00304
00305 bool
00306 SerializableHdf5Reader00::read_sgserializable_begin_wrapped(
00307 const TSGDataType* type, char* sgserializable_name,
00308 EPrimitiveType* generic)
00309 {
00310 if (!m_file->attr_exists(STR_IS_SGSERIALIZABLE)) return false;
00311
00312 if (m_file->attr_exists(STR_IS_NULL)) {
00313 *sgserializable_name = '\0'; return true;
00314 }
00315
00316 if (!m_file->attr_read_string(
00317 STR_INSTANCE_NAME, sgserializable_name, STRING_LEN))
00318 return false;
00319
00320 if (m_file->attr_exists(STR_GENERIC_NAME)) {
00321 string_t buf;
00322 if (!m_file->attr_read_string(
00323 STR_GENERIC_NAME, buf, STRING_LEN)) return false;
00324 if (!TSGDataType::string_to_ptype(generic, buf))
00325 return false;
00326 }
00327
00328 return true;
00329 }
00330
00331 bool
00332 SerializableHdf5Reader00::read_sgserializable_end_wrapped(
00333 const TSGDataType* type, const char* sgserializable_name,
00334 EPrimitiveType generic)
00335 {
00336 return true;
00337 }
00338
00339 bool
00340 SerializableHdf5Reader00::read_type_begin_wrapped(
00341 const TSGDataType* type, const char* name, const char* prefix)
00342 {
00343 CSerializableHdf5File::type_item_t* m = new CSerializableHdf5File
00344 ::type_item_t(name);
00345 m_file->m_stack_type.push_back(m);
00346
00347 if (type->m_ptype == PT_SGOBJECT) {
00348 if (!m_file->group_open(name, "")) return false;
00349 return true;
00350 }
00351
00352 if ((m->dset = H5Dopen2(m_file->m_stack_h5stream.back(), name,
00353 H5P_DEFAULT)) < 0)
00354 return false;
00355
00356 if ((m->dtype = H5Dget_type(m->dset)) < 0) return false;
00357 if (!CSerializableHdf5File::isequal_stype2hdf5(
00358 type->m_stype, type->m_ptype, m->dtype)) return false;
00359
00360 if ((m->dspace = H5Dget_space(m->dset)) < 0) return false;
00361
00362 if (H5Sget_simple_extent_ndims(m->dspace) > 2) return false;
00363 if ((m->rank = H5Sget_simple_extent_dims(m->dspace, m->dims, NULL)
00364 ) < 0) return false;
00365
00366 switch (type->m_ctype) {
00367 case CT_SCALAR:
00368 if (m->rank != 0) return false;
00369 if (type->m_stype == ST_STRING) m->vltype = new hvl_t[1];
00370 break;
00371 case CT_VECTOR:
00372 if (H5Sget_simple_extent_type(m->dspace) != H5S_NULL
00373 && m->rank != 1) return false;
00374 if (type->m_stype == ST_STRING)
00375 m->vltype = new hvl_t[m->dims[0]];
00376 break;
00377 case CT_MATRIX:
00378 if (H5Sget_simple_extent_type(m->dspace) != H5S_NULL
00379 && m->rank != 2) return false;
00380 if (type->m_stype == ST_STRING)
00381 m->vltype = new hvl_t[m->dims[0] *m->dims[1]];
00382 break;
00383 }
00384
00385 return true;
00386 }
00387
00388 bool
00389 SerializableHdf5Reader00::read_type_end_wrapped(
00390 const TSGDataType* type, const char* name, const char* prefix)
00391 {
00392 if (type->m_ptype == PT_SGOBJECT)
00393 if (!m_file->group_close()) return false;
00394
00395 delete m_file->m_stack_type.back();
00396 m_file->m_stack_type.pop_back();
00397 return true;
00398 }
00399
00400 #endif