← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/internal/mf_iocache.cc

  • Committer: Brian Aker
  • Date: 2011-04-29 16:12:27 UTC
  • mto: This revision was merged to the branch mainline in revision 2297.
  • Revision ID: brian@tangent.org-20110429161227-uba0tisioduoapwg
A couple of additional fixes for the IO Cache name,

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/internal/mf_iocache.cc
68
68
namespace internal
69
69
{
70
70
 
71
 
static int _my_b_read(st_io_cache *info, unsigned char *Buffer, size_t Count);
72
 
static int _my_b_write(st_io_cache *info, const unsigned char *Buffer, size_t Count);
 
71
static int _my_b_read(io_cache_st *info, unsigned char *Buffer, size_t Count);
 
72
static int _my_b_write(io_cache_st *info, const unsigned char *Buffer, size_t Count);
73
73
 
74
74
/**
75
75
 * @brief
76
 
 *   Lock appends for the st_io_cache if required (need_append_buffer_lock)   
 
76
 *   Lock appends for the io_cache_st if required (need_append_buffer_lock)   
77
77
 */
78
78
inline
79
 
static void lock_append_buffer(st_io_cache *, int )
 
79
static void lock_append_buffer(io_cache_st *, int )
80
80
{
81
81
}
82
82
 
83
83
/**
84
84
 * @brief
85
 
 *   Unlock appends for the st_io_cache if required (need_append_buffer_lock)   
 
85
 *   Unlock appends for the io_cache_st if required (need_append_buffer_lock)   
86
86
 */
87
87
inline
88
 
static void unlock_append_buffer(st_io_cache *, int )
 
88
static void unlock_append_buffer(io_cache_st *, int )
89
89
{
90
90
}
91
91
 
112
112
 
113
113
/**
114
114
 * @brief 
115
 
 *   Setup internal pointers inside st_io_cache
 
115
 *   Setup internal pointers inside io_cache_st
116
116
 * 
117
117
 * @details
118
 
 *   This is called on automatically on init or reinit of st_io_cache
119
 
 *   It must be called externally if one moves or copies an st_io_cache object.
 
118
 *   This is called on automatically on init or reinit of io_cache_st
 
119
 *   It must be called externally if one moves or copies an io_cache_st object.
120
120
 * 
121
121
 * @param info Cache handler to setup
122
122
 */
123
 
void st_io_cache::setup_io_cache()
 
123
void io_cache_st::setup_io_cache()
124
124
{
125
125
  /* Ensure that my_b_tell() and my_b_bytes_in_cache works */
126
126
  if (type == WRITE_CACHE)
136
136
}
137
137
 
138
138
 
139
 
void st_io_cache::init_functions()
 
139
void io_cache_st::init_functions()
140
140
{
141
141
  switch (type) {
142
142
  case READ_NET:
158
158
 
159
159
/**
160
160
 * @brief
161
 
 *   Initialize an st_io_cache object
 
161
 *   Initialize an io_cache_st object
162
162
 *
163
163
 * @param file File that should be associated with the handler
164
164
 *                 If == -1 then real_open_cached_file() will be called when it's time to open file.
173
173
 * @retval 0 success
174
174
 * @retval # error
175
175
 */
176
 
int st_io_cache::init_io_cache(int file_arg, size_t cachesize,
 
176
int io_cache_st::init_io_cache(int file_arg, size_t cachesize,
177
177
                               enum cache_type type_arg, my_off_t seek_offset,
178
178
                               bool use_async_io, myf cache_myflags)
179
179
{
297
297
 *   If we are doing a reinit of a cache where we have the start of the file
298
298
 *   in the cache, we are reusing this memory without flushing it to disk.
299
299
 */
300
 
bool st_io_cache::reinit_io_cache(enum cache_type type_arg,
 
300
bool io_cache_st::reinit_io_cache(enum cache_type type_arg,
301
301
                                  my_off_t seek_offset,
302
302
                                  bool,
303
303
                                  bool clear_cache)
385
385
 *   types than my_off_t unless you can be sure that their value fits.
386
386
 *   Same applies to differences of file offsets.
387
387
 *
388
 
 * @param info st_io_cache pointer @param Buffer Buffer to retrieve count bytes
 
388
 * @param info io_cache_st pointer @param Buffer Buffer to retrieve count bytes
389
389
 * from file @param Count Number of bytes to read into Buffer
390
390
 * 
391
391
 * @retval 0 We succeeded in reading all data
392
392
 * @retval 1 Error: can't read requested characters
393
393
 */
394
 
static int _my_b_read(st_io_cache *info, unsigned char *Buffer, size_t Count)
 
394
static int _my_b_read(io_cache_st *info, unsigned char *Buffer, size_t Count)
395
395
{
396
396
  size_t length_local,diff_length,left_length, max_length;
397
397
  my_off_t pos_in_file_local;
408
408
  pos_in_file_local=info->pos_in_file+ (size_t) (info->read_end - info->buffer);
409
409
 
410
410
  /*
411
 
    Whenever a function which operates on st_io_cache flushes/writes
412
 
    some part of the st_io_cache to disk it will set the property
 
411
    Whenever a function which operates on io_cache_st flushes/writes
 
412
    some part of the io_cache_st to disk it will set the property
413
413
    "seek_not_done" to indicate this to other functions operating
414
 
    on the st_io_cache.
 
414
    on the io_cache_st.
415
415
  */
416
416
  if (info->seek_not_done)
417
417
  {
491
491
 * @brief
492
492
 *   Read one byte when buffer is empty
493
493
 */
494
 
int _my_b_get(st_io_cache *info)
 
494
int _my_b_get(io_cache_st *info)
495
495
{
496
496
  unsigned char buff;
497
 
  io_cache_st_CALLBACK pre_read,post_read;
 
497
  IO_CACHE_CALLBACK pre_read,post_read;
 
498
 
498
499
  if ((pre_read = info->pre_read))
499
500
    (*pre_read)(info);
 
501
 
500
502
  if ((*(info)->read_function)(info,&buff,1))
501
503
    return my_b_EOF;
 
504
 
502
505
  if ((post_read = info->post_read))
503
506
    (*post_read)(info);
 
507
 
504
508
  return (int) (unsigned char) buff;
505
509
}
506
510
 
507
511
/**
508
512
 * @brief
509
 
 *   Write a byte buffer to st_io_cache and flush to disk if st_io_cache is full.
 
513
 *   Write a byte buffer to io_cache_st and flush to disk if io_cache_st is full.
510
514
 *
511
515
 * @retval -1 On error; errno contains error code.
512
516
 * @retval 0 On success
513
517
 * @retval 1 On error on write
514
518
 */
515
 
int _my_b_write(st_io_cache *info, const unsigned char *Buffer, size_t Count)
 
519
int _my_b_write(io_cache_st *info, const unsigned char *Buffer, size_t Count)
516
520
{
517
521
  size_t rest_length,length_local;
518
522
 
536
540
    if (info->seek_not_done)
537
541
    {
538
542
      /*
539
 
        Whenever a function which operates on st_io_cache flushes/writes
540
 
        some part of the st_io_cache to disk it will set the property
 
543
        Whenever a function which operates on io_cache_st flushes/writes
 
544
        some part of the io_cache_st to disk it will set the property
541
545
        "seek_not_done" to indicate this to other functions operating
542
 
        on the st_io_cache.
 
546
        on the io_cache_st.
543
547
      */
544
548
      if (lseek(info->file,info->pos_in_file,SEEK_SET))
545
549
      {
566
570
 *   As all write calls to the data goes through the cache,
567
571
 *   we will never get a seek over the end of the buffer.
568
572
 */
569
 
int my_block_write(st_io_cache *info, const unsigned char *Buffer, size_t Count,
 
573
int my_block_write(io_cache_st *info, const unsigned char *Buffer, size_t Count,
570
574
                   my_off_t pos)
571
575
{
572
576
  size_t length_local;
613
617
 * @brief
614
618
 *   Flush write cache 
615
619
 */
616
 
int my_b_flush_io_cache(st_io_cache *info, int need_append_buffer_lock)
 
620
int my_b_flush_io_cache(io_cache_st *info, int need_append_buffer_lock)
617
621
{
618
622
  size_t length_local;
619
623
  bool append_cache= false;
677
681
 
678
682
/**
679
683
 * @brief
680
 
 *   Free an st_io_cache object
 
684
 *   Free an io_cache_st object
681
685
 * 
682
686
 * @detail
683
687
 *   It's currently safe to call this if one has called init_io_cache()
684
688
 *   on the 'info' object, even if init_io_cache() failed.
685
689
 *   This function is also safe to call twice with the same handle.
686
690
 * 
687
 
 * @param info st_io_cache Handle to free
 
691
 * @param info io_cache_st Handle to free
688
692
 * 
689
693
 * @retval 0 ok
690
694
 * @retval # Error
691
695
 */
692
 
int st_io_cache::end_io_cache()
 
696
int io_cache_st::end_io_cache()
693
697
{
694
698
  int _error=0;
695
699