static void gen_data_ecl_write_ASCII(const gen_data_type * gen_data , const char * file , gen_data_file_format_type export_format) {
FILE * stream = util_fopen(file , "w");
char * template_buffer;
int template_data_offset, template_buffer_size , template_data_skip;
if (export_format == ASCII_TEMPLATE) {
gen_data_config_get_template_data( gen_data->config , &template_buffer , &template_data_offset , &template_buffer_size , &template_data_skip);
util_fwrite( template_buffer , 1 , template_data_offset , stream , __func__);
}
{
ecl_data_type internal_type = gen_data_config_get_internal_data_type(gen_data->config);
const int size = gen_data_config_get_data_size( gen_data->config , gen_data->current_report_step );
int i;
if (ecl_type_is_float(internal_type)) {
float * float_data = (float *) gen_data->data;
for (i=0; i < size; i++)
fprintf(stream , "%g\n",float_data[i]);
} else if (ecl_type_is_double(internal_type)) {
double * double_data = (double *) gen_data->data;
for (i=0; i < size; i++)
fprintf(stream , "%lg\n",double_data[i]);
} else
util_abort("%s: internal error - wrong type \n",__func__);
}
if (export_format == ASCII_TEMPLATE) {
int new_offset = template_data_offset + template_data_skip;
util_fwrite( &template_buffer[new_offset] , 1 , template_buffer_size - new_offset , stream , __func__);
}
fclose(stream);
}
void fortio_copy_record(fortio_type * src_stream , fortio_type * target_stream , int buffer_size , void * buffer , bool *at_eof) {
int bytes_read;
int record_size = fortio_init_read(src_stream);
fortio_init_write(target_stream , record_size);
bytes_read = 0;
while (bytes_read < record_size) {
int bytes;
if (record_size > buffer_size)
bytes = buffer_size;
else
bytes = record_size - bytes_read;
util_fread(buffer , 1 , bytes , src_stream->stream , __func__);
util_fwrite(buffer , 1 , bytes , target_stream->stream , __func__);
bytes_read += bytes;
}
fortio_complete_read(src_stream);
fortio_complete_write(target_stream);
if (feof(src_stream->stream))
*at_eof = true;
else
*at_eof = false;
}
void matrix_fwrite(const matrix_type * matrix , FILE * stream) {
util_fwrite_int( matrix->rows , stream );
util_fwrite_int( matrix->columns , stream );
if (matrix->column_stride == matrix->rows)
util_fwrite( 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) {
const double * column_data = &matrix->data[ column * matrix->column_stride ];
util_fwrite( column_data , sizeof * column_data , matrix->rows , stream , __func__);
} else {
int row;
for (row=0; row < matrix->rows; row++)
util_fwrite_double( matrix->data[ GET_INDEX( matrix , row , column )] , stream);
}
}
}
}
void test_fread_invalid_tail() {
test_work_area_type * work_area = test_work_area_alloc("fortio_invalid" );
int record_size = 10;
void * buffer = util_malloc( record_size );
{
FILE * stream = util_fopen("PRESSURE" , "w");
util_fwrite(&record_size , sizeof record_size , 1 , stream , __func__);
util_fwrite(buffer , 1 , record_size , stream , __func__);
util_fwrite(&record_size , sizeof record_size , 1 , stream , __func__);
util_fwrite(&record_size , sizeof record_size , 1 , stream , __func__);
util_fwrite(buffer , 1 , record_size , stream , __func__);
record_size += 1;
util_fwrite(&record_size , sizeof record_size , 1 , stream , __func__);
fclose(stream);
}
{
fortio_type * fortio = fortio_open_reader( "PRESSURE" , false , false );
record_size -= 1;
test_assert_true( fortio_fread_buffer( fortio , buffer , record_size ));
test_assert_false( fortio_fread_buffer( fortio , buffer , record_size ));
fortio_fclose( fortio );
}
free( buffer );
test_work_area_free( work_area );
}
size_t buffer_stream_fwrite_n( const buffer_type * buffer , size_t offset , ssize_t write_size , FILE * stream ) {
if (offset < 0 || offset > buffer->content_size)
util_abort("%s: invalid offset:%ld - valid range: [0,%ld) \n",__func__ , offset , offset);
{
ssize_t len;
if (write_size > 0) /* Normal - write @write_size bytes from offset */
len = write_size;
else if (write_size == 0) /* Write everything from the offset */
len = buffer->content_size - offset;
else /* @write_size < 0 - write everything excluding the last abs(write_size) bytes. */
len = buffer->content_size - offset - abs( write_size );
if (len < 0)
util_abort("%s: invalid length spesifier - tried to write %ld bytes \n",__func__ , len);
util_fwrite( &buffer->data[offset] , 1 , len , stream , __func__);
return len;
}
}
void @TYPE@_vector_fwrite(const @TYPE@_vector_type * vector , FILE * stream) {
util_fwrite_int( vector->size , stream );
util_fwrite( &vector->default_value , sizeof vector->default_value , 1 , stream , __func__);
@TYPE@_vector_fwrite_data( vector , stream );
}
void @TYPE@_vector_fwrite_data( const @TYPE@_vector_type * vector , FILE * stream ) {
util_fwrite( vector->data , sizeof * vector->data , vector->size , stream , __func__);
}
void fortio_fwrite_record(fortio_type *fortio, const char *buffer , int record_size) {
fortio_init_write(fortio , record_size);
util_fwrite( buffer , 1 , record_size , fortio->stream , __func__);
fortio_complete_write(fortio);
}
static void gen_data_ecl_write_binary(const gen_data_type * gen_data , const char * file , ecl_data_type export_type) {
FILE * stream = util_fopen(file , "w");
int sizeof_ctype = ecl_type_get_sizeof_ctype( export_type );
util_fwrite( gen_data->data , sizeof_ctype , gen_data_config_get_data_size( gen_data->config , gen_data->current_report_step) , stream , __func__);
fclose(stream);
}
