/*
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;
}
