← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/internal/iocache.h

  • Committer: Mark Atwood
  • Date: 2011-04-29 17:30:52 UTC
  • mfrom: (2296.1.2 local-fix)
  • Revision ID: me@mark.atwood.name-20110429173052-3hg0h8rxphrasm0s
merge ~brianaker/drizzle/iocached-rename

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/internal/iocache.h
27
27
namespace internal
28
28
{
29
29
 
30
 
struct st_io_cache;
31
 
typedef int (*IO_CACHE_CALLBACK)(struct st_io_cache*);
 
30
struct io_cache_st;
 
31
typedef int (*IO_CACHE_CALLBACK)(struct io_cache_st*);
32
32
 
33
 
struct st_io_cache    /* Used when cacheing files */
 
33
struct io_cache_st    /* Used when cacheing files */
34
34
{
35
35
  /* Offset in file corresponding to the first byte of unsigned char* buffer. */
36
36
  my_off_t pos_in_file;
77
77
    my_b_read() will call read_function to fetch the data. read_function
78
78
    must never be invoked directly.
79
79
  */
80
 
  int (*read_function)(struct st_io_cache *,unsigned char *,size_t);
 
80
  int (*read_function)(struct io_cache_st *,unsigned char *,size_t);
81
81
  /*
82
82
    Same idea as in the case of read_function, except my_b_write() needs to
83
83
    be replaced with my_b_append() for a SEQ_READ_APPEND cache
84
84
  */
85
 
  int (*write_function)(struct st_io_cache *,const unsigned char *,size_t);
 
85
  int (*write_function)(struct io_cache_st *,const unsigned char *,size_t);
86
86
  /*
87
87
    Specifies the type of the cache. Depending on the type of the cache
88
88
    certain operations might not be available and yield unpredicatable
94
94
    Callbacks when the actual read I/O happens. These were added and
95
95
    are currently used for binary logging of LOAD DATA INFILE - when a
96
96
    block is read from the file, we create a block create/append event, and
97
 
    when IO_CACHE is closed, we create an end event. These functions could,
 
97
    when io_cache_st is closed, we create an end event. These functions could,
98
98
    of course be used for other things
99
99
  */
100
100
  IO_CACHE_CALLBACK pre_read;
125
125
  */
126
126
  bool alloced_buffer;
127
127
 
128
 
  st_io_cache() :
 
128
  io_cache_st() :
129
129
    pos_in_file(0),
130
130
    end_of_file(0),
131
131
    read_pos(0),
157
157
    alloced_buffer(0)
158
158
  { }
159
159
 
160
 
  ~st_io_cache()
 
160
  ~io_cache_st()
161
161
  { }
162
162
 
163
163
  void close_cached_file();
179
179
 
180
180
};
181
181
 
182
 
typedef struct st_io_cache IO_CACHE;    /* Used when cacheing files */
183
 
 
184
 
extern int _my_b_get(st_io_cache *info);
185
 
extern int _my_b_async_read(st_io_cache *info,unsigned char *Buffer,size_t Count);
186
 
 
187
 
extern int my_block_write(st_io_cache *info, const unsigned char *Buffer,
 
182
typedef struct io_cache_st IO_CACHE;    /* Used when cacheing files */
 
183
 
 
184
extern int _my_b_get(io_cache_st *info);
 
185
extern int _my_b_async_read(io_cache_st *info,unsigned char *Buffer,size_t Count);
 
186
 
 
187
extern int my_block_write(io_cache_st *info, const unsigned char *Buffer,
188
188
                          size_t Count, my_off_t pos);
189
 
extern int my_b_flush_io_cache(st_io_cache *info, int need_append_buffer_lock);
 
189
extern int my_b_flush_io_cache(io_cache_st *info, int need_append_buffer_lock);
190
190
 
191
191
#define flush_io_cache(info) my_b_flush_io_cache((info),1)
192
192