/* When a stringlist is loaded from file the current content of the stringlist is discarded; and the stringlist becomes the owner of all the data read in. */ void stringlist_fread(stringlist_type * s, FILE * stream) { int size = util_fread_int(stream); int i; stringlist_clear(s); for (i=0; i < size; i++) stringlist_append_owned_ref( s , util_fread_alloc_string( stream )); }
enkf_fs_type * enkf_fs_mount( const char * mount_point , bool read_only) { FILE * stream = fs_driver_open_fstab( mount_point , false ); if (stream != NULL) { enkf_fs_type * fs = NULL; fs_driver_assert_magic( stream ); fs_driver_assert_version( stream , mount_point ); { fs_driver_impl driver_id = util_fread_int( stream ); switch( driver_id ) { case( BLOCK_FS_DRIVER_ID ): fs = enkf_fs_mount_block_fs( stream , mount_point , read_only ); break; case( PLAIN_DRIVER_ID ): fs = enkf_fs_mount_plain( stream , mount_point , read_only ); break; default: util_abort("%s: unrecognized driver_id:%d \n",__func__ , driver_id ); } } fclose( stream ); enkf_fs_init_path_fmt( fs ); enkf_fs_fread_time_map( fs ); enkf_fs_fread_cases_config( fs ); enkf_fs_fread_state_map( fs ); enkf_fs_fread_misfit( fs ); enkf_fs_get_ref( fs ); return fs; } return NULL; }
void cases_config_fread( cases_config_type * config , const char * filename) { if (util_file_exists( filename )) { FILE * stream = util_fopen( filename , "r"); int iteration_number = util_fread_int( stream ); cases_config_set_iteration_number(config,iteration_number); fclose( stream ); } }
void misfit_ensemble_fread( misfit_ensemble_type * misfit_ensemble , FILE * stream ) { misfit_ensemble_clear( misfit_ensemble ); { int ens_size; misfit_ensemble->history_length = util_fread_int( stream ); ens_size = util_fread_int( stream ); misfit_ensemble_set_ens_size( misfit_ensemble , ens_size ); { for (int iens = 0; iens < ens_size; iens++) { misfit_member_type * node = misfit_member_fread_alloc( stream ); vector_iset_owned_ref( misfit_ensemble->ensemble , iens , node , misfit_member_free__); } } } }
/* Observe that this function will reset the default value. */ void @TYPE@_vector_fread( @TYPE@_vector_type * vector , FILE * stream ) { @TYPE@ default_value; int size = util_fread_int( stream ); util_fread( &default_value , sizeof default_value , 1 , stream , __func__); { @TYPE@_vector_set_default( vector , default_value ); @TYPE@_vector_fread_data( vector , size , stream ); } }
static int enkf_fs_fread_fs_version__(FILE * stream) { int version; long fs_tag = util_fread_long( stream ); if (fs_tag == FS_MAGIC_ID) version = util_fread_int(stream); else version = 0; return version; }
void matrix_fread(matrix_type * matrix , FILE * stream) { int rows = util_fread_int( stream ); int columns = util_fread_int( stream ); matrix_resize( matrix , rows , columns , false); if (matrix->column_stride == matrix->rows) util_fread( matrix->data , sizeof * matrix->data , matrix->columns * matrix->rows , stream , __func__); else { int column; for (column=0; column < matrix->columns; column++) { if (matrix->row_stride == 1) { double * column_data = &matrix->data[ column * matrix->column_stride ]; util_fread( column_data , sizeof * column_data , matrix->rows , stream , __func__); } else { int row; for (row=0; row < matrix->rows; row++) matrix->data[ GET_INDEX( matrix , row , column )] = util_fread_double( stream ); } } } }
static enkf_fs_type * enkf_fs_mount_plain( FILE * fstab_stream , const char * mount_point , bool read_only ) { enkf_fs_type * fs = enkf_fs_alloc_empty( mount_point , read_only); { int driver_nr; for (driver_nr = 0; driver_nr < 5; driver_nr++) { fs_driver_enum driver_type = util_fread_int( fstab_stream ); fs_driver_type * driver = plain_driver_open( fstab_stream , mount_point ); enkf_fs_assign_driver( fs , driver , driver_type ); } } return fs; }
void fortio_complete_read(fortio_type *fortio) { int trailer; trailer = util_fread_int( fortio->stream ); if (fortio->endian_flip_header) util_endian_flip_vector(&trailer , sizeof trailer , 1); if (trailer != fortio->active_header) { fprintf(stderr,"%s: fatal error reading record:%d in file: %s - aborting \n",__func__ , fortio->rec_nr , fortio->filename); util_abort("%s: Header: %d Trailer: %d \n",__func__ , fortio->active_header , trailer); } fortio->active_header = 0; }
static enkf_fs_type * enkf_fs_mount_block_fs( FILE * fstab_stream , const char * mount_point , bool read_only ) { enkf_fs_type * fs = enkf_fs_alloc_empty( mount_point , read_only ); if (!read_only) { //Lock on fs level if (!util_try_lockf( fs->lock_file , S_IWUSR + S_IWGRP , &fs->lock_fd)) { fprintf(stderr," Another program has already opened filesystem read-write - this instance will be UNSYNCRONIZED read-only. Cross your fingers ....\n"); fflush( stderr ); enkf_fs_set_writable(fs, false); read_only = true; } } { int driver_nr; for (driver_nr = 0; driver_nr < 5; driver_nr++) { fs_driver_enum driver_type = util_fread_int( fstab_stream ); fs_driver_type * driver = block_fs_driver_open( fstab_stream , mount_point , driver_type , read_only); enkf_fs_assign_driver( fs , driver , driver_type ); } } return fs; }