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() {}
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* length)
00183 {
00184 CSerializableHdf5File::type_item_t* m_prev
00185 = m_file->m_stack_type.back();
00186
00187 if(!m_file->dspace_select(type->m_ctype, m_prev->y, m_prev->x))
00188 return false;
00189
00190 CSerializableHdf5File::type_item_t* m = new CSerializableHdf5File
00191 ::type_item_t(m_prev->name);
00192 m_file->m_stack_type.push_back(m);
00193
00194
00195
00196 if (!m_file->group_open(m->name, STR_GROUP_PREFIX)) return false;
00197 if (!m_file->attr_exists(STR_IS_SPARSE)) return false;
00198
00199 string_t name;
00200 CSerializableHdf5File::index2string(
00201 name, STRING_LEN, type->m_ctype, m_prev->y, m_prev->x);
00202 if ((m->dset = H5Dopen2(m_file->m_stack_h5stream.back(), name,
00203 H5P_DEFAULT)) < 0)
00204 return false;
00205
00206 if ((m->dtype = H5Dget_type(m->dset)) < 0) return false;
00207 if (!CSerializableHdf5File::isequal_stype2hdf5(
00208 type->m_stype, type->m_ptype, m->dtype)) return false;
00209
00210 if ((m->dspace = H5Dget_space(m->dset)) < 0) return false;
00211 if (H5Sget_simple_extent_ndims(m->dspace) != 1) return false;
00212
00213
00214 if ((m->rank = H5Sget_simple_extent_dims(m->dspace, m->dims, NULL)
00215 ) < 0) return false;
00216
00217 if (H5Sget_simple_extent_type(m->dspace) != H5S_NULL
00218 && m->rank != 1) return false;
00219
00220 *length = m->dims[0];
00221
00222
00223
00224 char* buf = SG_MALLOC(char, CSerializableHdf5File::sizeof_sparsetype());
00225
00226 hid_t mem_type_id;
00227 if ((mem_type_id = CSerializableHdf5File::new_sparsetype()) < 0)
00228 return false;
00229
00230 hid_t mem_space_id;
00231 if ((mem_space_id = H5Screate_simple(0, NULL, NULL)) < 0)
00232 return false;
00233
00234 if (H5Dread(m_prev->dset, mem_type_id, mem_space_id,
00235 m_prev->dspace, H5P_DEFAULT, buf) < 0) return false;
00236
00237 if (H5Sclose(mem_space_id) < 0) return false;
00238 if (H5Tclose(mem_type_id) < 0) return false;
00239
00240 delete buf;
00241
00242 return true;
00243 }
00244
00245 bool
00246 SerializableHdf5Reader00::read_sparse_end_wrapped(
00247 const TSGDataType* type, index_t length)
00248 {
00249 if (!m_file->group_close()) return false;
00250
00251 delete m_file->m_stack_type.back();
00252 m_file->m_stack_type.pop_back();
00253
00254 return true;
00255 }
00256
00257 bool
00258 SerializableHdf5Reader00::read_sparseentry_begin_wrapped(
00259 const TSGDataType* type, SGSparseVectorEntry<char>* first_entry,
00260 index_t* feat_index, index_t y)
00261 {
00262 CSerializableHdf5File::type_item_t* m
00263 = m_file->m_stack_type.back();
00264
00265 m->sparse_ptr = first_entry;
00266 m->sub_y = y;
00267
00268 return true;
00269 }
00270
00271 bool
00272 SerializableHdf5Reader00::read_sparseentry_end_wrapped(
00273 const TSGDataType* type, SGSparseVectorEntry<char>* first_entry,
00274 index_t* feat_index, index_t y)
00275 {
00276 return true;
00277 }
00278
00279 bool
00280 SerializableHdf5Reader00::read_item_begin_wrapped(
00281 const TSGDataType* type, index_t y, index_t x)
00282 {
00283 CSerializableHdf5File::type_item_t* m
00284 = m_file->m_stack_type.back();
00285 m->y = y; m->x = x;
00286
00287 if (type->m_ptype != PT_SGOBJECT) return true;
00288
00289 string_t name;
00290 if (!CSerializableHdf5File::index2string(
00291 name, STRING_LEN, type->m_ctype, y, x)) return false;
00292 if (!m_file->group_open(name, "")) return false;
00293
00294 return true;
00295 }
00296
00297 bool
00298 SerializableHdf5Reader00::read_item_end_wrapped(
00299 const TSGDataType* type, index_t y, index_t x)
00300 {
00301 if (type->m_ptype == PT_SGOBJECT)
00302 if (!m_file->group_close()) return false;
00303
00304 return true;
00305 }
00306
00307 bool
00308 SerializableHdf5Reader00::read_sgserializable_begin_wrapped(
00309 const TSGDataType* type, char* sgserializable_name,
00310 EPrimitiveType* generic)
00311 {
00312 if (!m_file->attr_exists(STR_IS_SGSERIALIZABLE)) return false;
00313
00314 if (m_file->attr_exists(STR_IS_NULL)) {
00315 *sgserializable_name = '\0'; return true;
00316 }
00317
00318 if (!m_file->attr_read_string(
00319 STR_INSTANCE_NAME, sgserializable_name, STRING_LEN))
00320 return false;
00321
00322 if (m_file->attr_exists(STR_GENERIC_NAME)) {
00323 string_t buf;
00324 if (!m_file->attr_read_string(
00325 STR_GENERIC_NAME, buf, STRING_LEN)) return false;
00326 if (!TSGDataType::string_to_ptype(generic, buf))
00327 return false;
00328 }
00329
00330 return true;
00331 }
00332
00333 bool
00334 SerializableHdf5Reader00::read_sgserializable_end_wrapped(
00335 const TSGDataType* type, const char* sgserializable_name,
00336 EPrimitiveType generic)
00337 {
00338 return true;
00339 }
00340
00341 bool
00342 SerializableHdf5Reader00::read_type_begin_wrapped(
00343 const TSGDataType* type, const char* name, const char* prefix)
00344 {
00345 CSerializableHdf5File::type_item_t* m = new CSerializableHdf5File
00346 ::type_item_t(name);
00347 m_file->m_stack_type.push_back(m);
00348
00349 if (type->m_ptype == PT_SGOBJECT) {
00350 if (!m_file->group_open(name, "")) return false;
00351 return true;
00352 }
00353
00354 if ((m->dset = H5Dopen2(m_file->m_stack_h5stream.back(), name,
00355 H5P_DEFAULT)) < 0)
00356 return false;
00357
00358 if ((m->dtype = H5Dget_type(m->dset)) < 0) return false;
00359 if (!CSerializableHdf5File::isequal_stype2hdf5(
00360 type->m_stype, type->m_ptype, m->dtype)) return false;
00361
00362 if ((m->dspace = H5Dget_space(m->dset)) < 0) return false;
00363
00364 if (H5Sget_simple_extent_ndims(m->dspace) > 2) return false;
00365 if ((m->rank = H5Sget_simple_extent_dims(m->dspace, m->dims, NULL)
00366 ) < 0) return false;
00367
00368 switch (type->m_ctype) {
00369 case CT_NDARRAY:
00370 SG_NOTIMPLEMENTED;
00371 case CT_SCALAR:
00372 if (m->rank != 0) return false;
00373 if (type->m_stype == ST_STRING) m->vltype = SG_MALLOC(hvl_t, 1);
00374 break;
00375 case CT_VECTOR: case CT_SGVECTOR:
00376 if (H5Sget_simple_extent_type(m->dspace) != H5S_NULL
00377 && m->rank != 1) return false;
00378 if (type->m_stype == ST_STRING)
00379 m->vltype = SG_MALLOC(hvl_t, m->dims[0]);
00380 break;
00381 case CT_MATRIX: case CT_SGMATRIX:
00382 if (H5Sget_simple_extent_type(m->dspace) != H5S_NULL
00383 && m->rank != 2) return false;
00384 if (type->m_stype == ST_STRING)
00385 m->vltype = SG_MALLOC(hvl_t, m->dims[0] *m->dims[1]);
00386 break;
00387 default: return false;
00388 }
00389
00390 return true;
00391 }
00392
00393 bool
00394 SerializableHdf5Reader00::read_type_end_wrapped(
00395 const TSGDataType* type, const char* name, const char* prefix)
00396 {
00397 if (type->m_ptype == PT_SGOBJECT)
00398 if (!m_file->group_close()) return false;
00399
00400 delete m_file->m_stack_type.back();
00401 m_file->m_stack_type.pop_back();
00402 return true;
00403 }
00404
00405 #endif