sc_io.h

Go to the documentation of this file.

/*
  This file is part of the SC Library.
  The SC Library provides support for parallel scientific applications.
 
  Copyright (C) 2010 The University of Texas System
  Additional copyright (C) 2011 individual authors
 
  The SC Library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
 
  The SC Library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public
  License along with the SC Library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.
*/
 
#ifndef SC_IO_H
#define SC_IO_H
 
#include <sc_containers.h>
 
#define SC_CHECK_MPI_VERBOSE(errcode,user_msg) do {            \
  char sc_msg[sc_MPI_MAX_ERROR_STRING];                        \
  int sc_msglen;                                               \
  if ((errcode) != sc_MPI_SUCCESS) {                           \
    sc_MPI_Error_string (errcode, sc_msg, &sc_msglen);         \
    SC_LERRORF ("%s at %s:%d: %s\n",                           \
                (user_msg), __FILE__, __LINE__, sc_msg);       \
  }} while (0)
 
SC_EXTERN_C_BEGIN;
 
typedef enum
{
  SC_IO_ERROR_NONE,     
  SC_IO_ERROR_FATAL = -1,       
  SC_IO_ERROR_AGAIN = -2        
}
sc_io_error_t;
 
typedef enum
{
  SC_IO_MODE_WRITE,     
  SC_IO_MODE_APPEND,    
  SC_IO_MODE_LAST       
}
sc_io_mode_t;
 
typedef enum
{
  SC_IO_ENCODE_NONE,    
  SC_IO_ENCODE_LAST     
}
sc_io_encode_t;
 
typedef enum
{
  SC_IO_TYPE_BUFFER,    
  SC_IO_TYPE_FILENAME,  
  SC_IO_TYPE_FILEFILE,  
  SC_IO_TYPE_LAST       
}
sc_io_type_t;
 
typedef struct sc_io_sink
{
  sc_io_type_t        iotype;          
  sc_io_mode_t        mode;            
  sc_io_encode_t      encode;          
  sc_array_t         *buffer;          
  size_t              buffer_bytes;    
  FILE               *file;            
  size_t              bytes_in;        
  size_t              bytes_out;       
  int                 is_eof;          
}
sc_io_sink_t;
 
typedef struct sc_io_source
{
  sc_io_type_t        iotype;          
  sc_io_encode_t      encode;          
  sc_array_t         *buffer;          
  size_t              buffer_bytes;    
  FILE               *file;            
  size_t              bytes_in;        
  size_t              bytes_out;       
  int                 is_eof;          
  sc_io_sink_t       *mirror;          
  sc_array_t         *mirror_buffer;   
}
sc_io_source_t;
 
typedef enum
{
  SC_IO_READ,                         
  SC_IO_WRITE_CREATE,                 
  SC_IO_WRITE_APPEND                  
}
sc_io_open_mode_t;
 
sc_io_sink_t       *sc_io_sink_new (int iotype, int iomode,
                                    int ioencode, ...);
 
int                 sc_io_sink_destroy (sc_io_sink_t * sink);
 
int                 sc_io_sink_destroy_null (sc_io_sink_t ** sink);
 
int                 sc_io_sink_write (sc_io_sink_t * sink,
                                      const void *data, size_t bytes_avail);
 
int                 sc_io_sink_complete (sc_io_sink_t * sink,
                                         size_t *bytes_in, size_t *bytes_out);
 
int                 sc_io_sink_align (sc_io_sink_t * sink,
                                      size_t bytes_align);
 
sc_io_source_t     *sc_io_source_new (int iotype, int ioencode, ...);
 
int                 sc_io_source_destroy (sc_io_source_t * source);
 
int                 sc_io_source_destroy_null (sc_io_source_t ** source);
 
int                 sc_io_source_read (sc_io_source_t * source,
                                       void *data, size_t bytes_avail,
                                       size_t *bytes_out);
 
int                 sc_io_source_complete (sc_io_source_t * source,
                                           size_t *bytes_in,
                                           size_t *bytes_out);
 
int                 sc_io_source_align (sc_io_source_t * source,
                                        size_t bytes_align);
 
int                 sc_io_source_activate_mirror (sc_io_source_t * source);
 
int                 sc_io_source_read_mirror (sc_io_source_t * source,
                                              void *data,
                                              size_t bytes_avail,
                                              size_t *bytes_out);
 
int                 sc_io_file_save (const char *filename,
                                     sc_array_t * buffer);
 
int                 sc_io_file_load (const char *filename,
                                     sc_array_t * buffer);
 
void                sc_io_encode (sc_array_t *data, sc_array_t *out);
 
void                sc_io_encode_zlib (sc_array_t *data, sc_array_t *out,
                                       int zlib_compression_level,
                                       int line_break_character);
 
int                 sc_io_decode_info (sc_array_t *data,
                                       size_t *original_size,
                                       char *format_char, void *re);
 
int                 sc_io_decode (sc_array_t *data, sc_array_t *out,
                                  size_t max_original_size, void *re);
 
int                 sc_vtk_write_binary (FILE * vtkfile, char *numeric_data,
                                         size_t byte_length);
 
int                 sc_vtk_write_compressed (FILE * vtkfile,
                                             char *numeric_data,
                                             size_t byte_length);
 
FILE               *sc_fopen (const char *filename, const char *mode,
                              const char *errmsg);
 
void                sc_fwrite (const void *ptr, size_t size,
                               size_t nmemb, FILE * file, const char *errmsg);
 
void                sc_fread (void *ptr, size_t size,
                              size_t nmemb, FILE * file, const char *errmsg);
 
void                sc_fflush_fsync_fclose (FILE * file);
 
int                 sc_io_open (sc_MPI_Comm mpicomm,
                                const char *filename, sc_io_open_mode_t amode,
                                sc_MPI_Info mpiinfo, sc_MPI_File * mpifile);
 
#define sc_mpi_read         sc_io_read   
void                sc_io_read (sc_MPI_File mpifile, void *ptr,
                                size_t zcount, sc_MPI_Datatype t,
                                const char *errmsg);
 
int                 sc_io_read_at (sc_MPI_File mpifile,
                                   sc_MPI_Offset offset, void *ptr,
                                   int count, sc_MPI_Datatype t,
                                   int *ocount);
 
int                 sc_io_read_at_all (sc_MPI_File mpifile,
                                       sc_MPI_Offset offset, void *ptr,
                                       int count, sc_MPI_Datatype t,
                                       int *ocount);
 
#define sc_mpi_write        sc_io_write  
void                sc_io_write (sc_MPI_File mpifile, const void *ptr,
                                 size_t zcount, sc_MPI_Datatype t,
                                 const char *errmsg);
 
int                 sc_io_write_at (sc_MPI_File mpifile,
                                    sc_MPI_Offset offset,
                                    const void *ptr, int count,
                                    sc_MPI_Datatype t, int *ocount);
 
int                 sc_io_write_at_all (sc_MPI_File mpifile,
                                        sc_MPI_Offset offset,
                                        const void *ptr, int count,
                                        sc_MPI_Datatype t, int *ocount);
 
int                 sc_io_close (sc_MPI_File * file);
 
SC_EXTERN_C_END;
 
#endif /* SC_IO_H */