stream.h

这个是内存数据库中的一个管理工具

#ifndef _STREAM_H_
#define _STREAM_H_

/*
 * File: stream.h
 * Auteur: Niels J. Nes
 * Date: 09-01-2001
 *
 * Version 0.1: start
 *
 * This is the general interface to input/output. Each stream will
 * contains some stream info (for now only byteorder). This is
 * required for proper conversion on different byte order platforms.
 */

#include <monet_utils.h>

#include <unistd.h>
#include <ctype.h>
#include <assert.h>

#ifdef HAVE_MALLOC_H
#include <malloc.h>
#endif
#include <signal.h>
#include <limits.h>

#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#ifdef NATIVE_WIN32
# include <winsock.h>
#endif

#ifdef NATIVE_WIN32
#ifndef LIBSTREAM
#define stream_export extern __declspec(dllimport)
#else
#define stream_export extern __declspec(dllexport)
#endif
#else
#define stream_export extern
#endif

#define EOT 4

#define ST_ASCII  0
#define ST_BIN 1

#define ST_READ  0
#define ST_WRITE 1

#define short_int_SWAP(s) ((short)(((0x00ff&(s))<<8) | ((0xff00&(s))>>8)))

#define normal_int_SWAP(i) (((0x000000ff&(i))<<24) | ((0x0000ff00&(i))<<8) | \
	               ((0x00ff0000&(i))>>8)  | ((0xff000000&(i))>>24))

#define long_long_SWAP(l) \
		((((lng)normal_int_SWAP(l))<<32) |\
		 (0xffffffff&normal_int_SWAP(l>>32)))

typedef struct stream stream;

/* some os specific initialization */
stream_export int stream_init(void);

/* all stream_readX/stream_writeX 
   return 
	0 on error 
       !0 on success
 */
stream_export int stream_readBte(stream *s, signed char *val);
stream_export int stream_writeBte(stream *s, signed char val);
stream_export int stream_readSht(stream *s, short *val);
stream_export int stream_writeSht(stream *s, short val);
stream_export int stream_readInt(stream *s, int *val);
stream_export int stream_writeInt(stream *s, int val);
stream_export int stream_readLng(stream *s, lng *val);
stream_export int stream_writeLng(stream *s, lng val);

stream_export int stream_readBteArray(stream *s, signed char *val, size_t cnt);
stream_export int stream_writeBteArray(stream *s, const signed char *val, size_t cnt);
stream_export int stream_readShtArray(stream *s, short *val, size_t cnt);
stream_export int stream_writeShtArray(stream *s, const short *val, size_t cnt);
stream_export int stream_readIntArray(stream *s, int *val, size_t cnt);
stream_export int stream_writeIntArray(stream *s, const int *val, size_t cnt);
stream_export int stream_readLngArray(stream *s, lng *val, size_t cnt);
stream_export int stream_writeLngArray(stream *s, const lng *val, size_t cnt);
stream_export int stream_printf(stream *s, const char *format, ...);
stream_export ssize_t stream_read(stream *s, void *buf, size_t elmsize, size_t cnt);
stream_export ssize_t stream_readline(stream *s, void *buf, size_t maxcnt);
stream_export ssize_t stream_write(stream *s, const void *buf, size_t elmsize, size_t cnt);
stream_export void stream_close(stream *s);
stream_export void stream_destroy(stream *s);
stream_export char *stream_error(stream *s);
stream_export int stream_flush(stream *s);
stream_export int stream_fsync(stream *s);
stream_export char *stream_name(stream *s);
stream_export int stream_errnr(stream *s);
stream_export int stream_type(stream *s);
stream_export int stream_byteorder(stream *s);
stream_export void stream_set_byteorder(stream *s, char bigendian);
stream_export stream *stream_rstream(stream *s);
stream_export stream *stream_wstream(stream *s);

stream_export stream *open_rstream(const char *filename);
stream_export stream *open_wstream(const char *filename);

/* append to stream */
stream_export stream *append_wstream(const char *filename);

/* open in ascii stream in read mode */
stream_export stream *open_rastream(const char *filename);

/* open in ascii stream in write mode*/
stream_export stream *open_wastream(const char *filename);

/* append to ascii stream */
stream_export stream *append_wastream(const char *filename);

#ifdef HAVE_LIBZ
stream_export stream *open_gzrstream(const char *filename);
stream_export stream *open_gzwstream(const char *filename);
stream_export stream *open_gzrastream(const char *filename);
stream_export stream *open_gzwastream(const char *filename);
#endif

#ifdef HAVE_LIBBZ2
stream_export stream *open_bzrstream(const char *filename);
stream_export stream *open_bzwstream(const char *filename);
stream_export stream *open_bzrastream(const char *filename);
stream_export stream *open_bzwastream(const char *filename);
#endif

stream_export void close_stream(stream *s);

#ifdef HAVE_CURL
stream_export stream * open_urlstream(const char *url);
#endif

stream_export stream *socket_rstream(SOCKET socket, const char *name);
stream_export stream *socket_wstream(SOCKET socket, const char *name);
stream_export stream *socket_rastream(SOCKET socket, const char *name);
stream_export stream *socket_wastream(SOCKET socket, const char *name);

#ifdef HAVE_OPENSSL
#include <openssl/ssl.h>
#include <openssl/err.h>

stream_export stream *ssl_rstream(SSL * ssl, const char *name);
stream_export stream *ssl_wstream(SSL * ssl, const char *name);
stream_export stream *ssl_rastream(SSL * ssl, const char *name);
stream_export stream *ssl_wastream(SSL * ssl, const char *name);
#endif

stream_export stream *file_rstream(FILE *fp, const char *name);
stream_export stream *file_wstream(FILE *fp, const char *name);
stream_export stream *file_rastream(FILE *fp, const char *name);
stream_export stream *file_wastream(FILE *fp, const char *name);

stream_export int rendezvous_streams(stream **in, stream **out, const char *name);

typedef struct buffer {
	char *buf;
	size_t pos;
	size_t len;
} buffer;

stream_export void buffer_init(buffer *b, char *buf, size_t size);
stream_export buffer *buffer_create(size_t size);
stream_export char *buffer_get_buf(buffer *b);
stream_export void buffer_destroy(buffer *b);

stream_export stream *buffer_rastream(buffer *b, const char *name);
stream_export stream *buffer_wastream(buffer *b, const char *name);
stream_export buffer *stream_get_buffer(stream *s);

/* note, the size is fixed to 8K, you cannot simply change it to any
   value */
#define BLOCK (8 * 1024 - 2)
/*
   Block stream is a stream which sends data in blocks of a known
   size (BLOCK size or dynamically changed using CHANGE_BLOCK_SIZE msg).

   A block is written once more then BLOCK size data has been written using
   the write commands or when the flush command is sent.

   All full blocks together with a single not full block form a major
   block. Major blocks can be used to synchronize the communication.
   Example server sends some reply, ie a major block consisting of
   various minor blocks. The header of the major block can contain
   special info which the client can interpret.

   Each read attempt tries to return the number of bytes. Once a lower number
   of bytes can be read the end of the major block is found. The next
   read will then start with a new major block.
 */
stream_export stream *block_stream(stream *s);
stream_export ssize_t bs_read_next(stream *s, void *buf, size_t nbytes, int *last);
stream_export int isa_block_stream(stream *s);
/* read block of data including the end of block marker */
stream_export ssize_t stream_read_block(stream *s, void *buf, size_t elmsize, size_t cnt);



typedef struct bstream {
	stream *s;
	char *buf;
	size_t size;		/* size of buf */
	size_t pos;		/* the data cursor (ie read uptil pos) */
	size_t len;		/* len of the data (could < size but usually == size) */
	int eof;
	int mode;		/* 0 line mode else size for block mode */
} bstream;

stream_export bstream *bstream_create(stream *rs, size_t chunk_size);
stream_export void bstream_destroy(bstream *s);
stream_export ssize_t bstream_read(bstream *s, size_t size);
stream_export ssize_t bstream_next(bstream *s);




typedef enum stream_errors {
	NO__ERROR = 0,
	OPEN_ERROR,
	READ_ERROR,
	WRITE_ERROR
} stream_errors;
#endif /*_STREAM_H_*/