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