← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/internal/mf_iocache.cc

  • Committer: Mark Atwood
  • Date: 2011-08-17 19:14:47 UTC
  • mfrom: (2385.3.17 rf)
  • Revision ID: me@mark.atwood.name-20110817191447-h86yzddvycd0xmof
merge lp:~olafvdspek/drizzle/refactor6

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/internal/mf_iocache.cc
63
63
 
64
64
using namespace std;
65
65
 
66
 
namespace drizzled
67
 
{
68
 
namespace internal
69
 
{
 
66
namespace drizzled {
 
67
namespace internal {
70
68
 
71
69
static int _my_b_read(io_cache_st *info, unsigned char *Buffer, size_t Count);
72
70
static int _my_b_write(io_cache_st *info, const unsigned char *Buffer, size_t Count);
291
289
  /* If the whole file is in memory, avoid flushing to disk */
292
290
  if (! clear_cache &&
293
291
      seek_offset >= pos_in_file &&
294
 
      seek_offset <= my_b_tell(this))
 
292
      seek_offset <= tell())
295
293
  {
296
294
    /* Reuse current buffer without flushing it to disk */
297
295
    unsigned char *pos;
298
296
    if (type == WRITE_CACHE && type_arg == READ_CACHE)
299
297
    {
300
298
      read_end=write_pos;
301
 
      end_of_file=my_b_tell(this);
 
299
      end_of_file= tell();
302
300
      /*
303
301
        Trigger a new seek only if we have a valid
304
302
        file handle.
327
325
      after the current positions should be ignored
328
326
    */
329
327
    if (type == WRITE_CACHE && type_arg == READ_CACHE)
330
 
      end_of_file=my_b_tell(this);
 
328
      end_of_file= tell();
331
329
    /* flush cache if we want to reuse it */
332
 
    if (!clear_cache && my_b_flush_io_cache(this, 1))
 
330
    if (!clear_cache && flush(1))
333
331
      return 1;
334
332
    pos_in_file=seek_offset;
335
333
    /* Better to do always do a seek */
341
339
    }
342
340
    else
343
341
    {
344
 
      write_end=(buffer + buffer_length -
345
 
                       (seek_offset & (IO_SIZE-1)));
 
342
      write_end= (buffer + buffer_length - (seek_offset & (IO_SIZE-1)));
346
343
      end_of_file= ~(my_off_t) 0;
347
344
    }
348
345
  }
473
470
 * @brief
474
471
 *   Read one byte when buffer is empty
475
472
 */
476
 
int _my_b_get(io_cache_st *info)
 
473
int io_cache_st::get()
477
474
{
 
475
  if (read_pos != read_end)
 
476
    return *read_pos++;
 
477
 
 
478
  if (pre_read)
 
479
    pre_read(this);
 
480
 
478
481
  unsigned char buff;
479
 
  IO_CACHE_CALLBACK pre_read,post_read;
480
 
 
481
 
  if ((pre_read = info->pre_read))
482
 
    (*pre_read)(info);
483
 
 
484
 
  if ((*(info)->read_function)(info,&buff,1))
 
482
  if (read_function(this, &buff, 1))
485
483
    return my_b_EOF;
486
484
 
487
 
  if ((post_read = info->post_read))
488
 
    (*post_read)(info);
 
485
  if (post_read)
 
486
    post_read(this);
489
487
 
490
 
  return (int) (unsigned char) buff;
 
488
  return buff;
491
489
}
492
490
 
493
491
/**
514
512
  Count-=rest_length;
515
513
  info->write_pos+=rest_length;
516
514
 
517
 
  if (my_b_flush_io_cache(info,1))
 
515
  if (info->flush(1))
518
516
    return 1;
519
517
  if (Count >= IO_SIZE)
520
518
  {                                     /* Fill first intern buffer */
552
550
 *   As all write calls to the data goes through the cache,
553
551
 *   we will never get a seek over the end of the buffer.
554
552
 */
555
 
int my_block_write(io_cache_st *info, const unsigned char *Buffer, size_t Count,
556
 
                   my_off_t pos)
 
553
static int my_block_write(io_cache_st *info, const unsigned char *Buffer, size_t Count, my_off_t pos)
557
554
{
558
555
  size_t length_local;
559
556
  int error=0;
595
592
  return error;
596
593
}
597
594
 
 
595
int io_cache_st::block_write(const void* Buffer, size_t Count, my_off_t pos)
 
596
{
 
597
  return my_block_write(this, reinterpret_cast<const unsigned char*>(Buffer), Count, pos);
 
598
}
 
599
 
598
600
/**
599
601
 * @brief
600
602
 *   Flush write cache 
601
603
 */
602
 
int my_b_flush_io_cache(io_cache_st *info, int need_append_buffer_lock)
 
604
static int my_b_flush_io_cache(io_cache_st *info, int need_append_buffer_lock)
603
605
{
604
606
  size_t length_local;
605
607
  bool append_cache= false;
661
663
  return 0;
662
664
}
663
665
 
 
666
int io_cache_st::flush(int need_append_buffer_lock)
 
667
{
 
668
  return my_b_flush_io_cache(this, need_append_buffer_lock);
 
669
}
 
670
 
664
671
/**
665
672
 * @brief
666
673
 *   Free an io_cache_st object