← 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-08-17 06:10:57 UTC
  • Revision ID: me@mark.atwood.name-20110817061057-7hsj5c0dc4n3grrr
link docs/ipv6_data_type.rst to TOC in docs/columntypes.rst

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/internal/iocache.h
22
22
 
23
23
#include <drizzled/internal/my_sys.h>
24
24
 
25
 
namespace drizzled {
26
 
namespace internal {
27
 
 
28
 
#define my_b_EOF INT_MIN
29
 
 
30
 
class io_cache_st    /* Used when cacheing files */
31
 
{
32
 
public:
33
 
  typedef int (*IO_CACHE_CALLBACK)(io_cache_st*);
34
 
 
 
25
namespace drizzled
 
26
{
 
27
namespace internal
 
28
{
 
29
 
 
30
struct io_cache_st;
 
31
typedef int (*IO_CACHE_CALLBACK)(struct io_cache_st*);
 
32
 
 
33
struct io_cache_st    /* Used when cacheing files */
 
34
{
35
35
  /* Offset in file corresponding to the first byte of unsigned char* buffer. */
36
36
  my_off_t pos_in_file;
37
37
  /*
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)(io_cache_st* ,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)(io_cache_st* ,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
89
89
    results. Details to be documented later
90
90
  */
91
 
  cache_type type;
 
91
  enum cache_type type;
92
92
  int error;
93
93
  /*
94
94
    Callbacks when the actual read I/O happens. These were added and
157
157
    alloced_buffer(0)
158
158
  { }
159
159
 
160
 
  int get();
161
 
  int block_write(const void*, size_t, my_off_t);
 
160
  ~io_cache_st()
 
161
  { }
 
162
 
162
163
  void close_cached_file();
163
164
  bool real_open_cached_file();
164
165
  int end_io_cache();
165
 
  int init_io_cache(int file, size_t cachesize, cache_type type, my_off_t seek_offset, bool use_async_io, myf cache_myflags);
 
166
  int init_io_cache(int file, size_t cachesize,
 
167
                    enum cache_type type, my_off_t seek_offset,
 
168
                    bool use_async_io, myf cache_myflags);
166
169
  void init_functions();
167
170
 
168
 
  bool reinit_io_cache(cache_type type_arg, my_off_t seek_offset, bool use_async_io, bool clear_cache);
 
171
  bool reinit_io_cache(enum cache_type type_arg,
 
172
                       my_off_t seek_offset,
 
173
                       bool use_async_io,
 
174
                       bool clear_cache);
169
175
  void setup_io_cache();
170
 
  bool open_cached_file(const char *dir, const char *prefix, size_t cache_size, myf cache_myflags);
171
 
  int flush(int need_append_buffer_lock= 1);
172
 
 
173
 
  void clear()
174
 
  {
175
 
    buffer= NULL;
176
 
  }
177
 
 
178
 
  bool inited() const
179
 
  {
180
 
    return buffer;
181
 
  }
182
 
 
183
 
  my_off_t tell() const
184
 
  {
185
 
    return pos_in_file + *current_pos - request_pos;
186
 
  }
187
 
 
188
 
  int read(void* Buffer0, size_t Count)
189
 
  {
190
 
    unsigned char* Buffer= reinterpret_cast<unsigned char*>(Buffer0);
191
 
    if (read_pos + Count > read_end)
192
 
      return read_function(this, Buffer, Count);
193
 
    memcpy(Buffer, read_pos, Count);
194
 
    read_pos += Count;
195
 
    return 0;
196
 
  }
197
 
 
198
 
  int write(const void* Buffer0, size_t Count)
199
 
  {
200
 
    const unsigned char* Buffer= reinterpret_cast<const unsigned char*>(Buffer0);
201
 
    if (write_pos + Count > write_end)
202
 
      return write_function(this, Buffer, Count);
203
 
    memcpy(write_pos, Buffer, Count);
204
 
    write_pos += Count;
205
 
    return 0;
206
 
  }
 
176
  bool open_cached_file(const char *dir,
 
177
                        const char *prefix, size_t cache_size,
 
178
                        myf cache_myflags);
 
179
 
207
180
};
208
181
 
 
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
                          size_t Count, my_off_t pos);
 
189
extern int my_b_flush_io_cache(io_cache_st *info, int need_append_buffer_lock);
 
190
 
 
191
#define flush_io_cache(info) my_b_flush_io_cache((info),1)
 
192
 
209
193
} /* namespace internal */
210
194
} /* namespace drizzled */
 
195