← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/dynamic_array.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/dynamic_array.cc
46
46
    false       Ok
47
47
*/
48
48
 
49
 
void init_dynamic_array2(DYNAMIC_ARRAY *array, uint32_t element_size,
50
 
                            void *init_buffer, uint32_t init_alloc,
51
 
                            uint32_t alloc_increment)
 
49
static void init_dynamic_array2(DYNAMIC_ARRAY* array, uint32_t element_size, uint32_t init_alloc, uint32_t alloc_increment)
52
50
{
53
51
  if (!alloc_increment)
54
52
  {
55
 
    alloc_increment=max((8192-MALLOC_OVERHEAD)/element_size,16U);
 
53
    alloc_increment= max((8192 - MALLOC_OVERHEAD) / element_size, 16U);
56
54
    if (init_alloc > 8 && alloc_increment > init_alloc * 2)
57
 
      alloc_increment=init_alloc*2;
58
 
  }
59
 
 
60
 
  if (!init_alloc)
61
 
  {
62
 
    init_alloc=alloc_increment;
63
 
    init_buffer= 0;
64
 
  }
 
55
      alloc_increment= init_alloc * 2;
 
56
  }
 
57
  if (not init_alloc)
 
58
    init_alloc= alloc_increment;
65
59
  array->set_size(0);
66
 
  array->max_element=init_alloc;
67
 
  array->alloc_increment=alloc_increment;
68
 
  array->size_of_element=element_size;
69
 
  if ((array->buffer= (unsigned char*) init_buffer))
70
 
    return;
71
 
  array->buffer= (unsigned char*) malloc(element_size*init_alloc);
 
60
  array->max_element= init_alloc;
 
61
  array->alloc_increment= alloc_increment;
 
62
  array->size_of_element= element_size;
 
63
  array->buffer= (unsigned char*) malloc(element_size * init_alloc);
 
64
}
 
65
 
 
66
void DYNAMIC_ARRAY::init(uint32_t element_size, uint32_t init_alloc, uint32_t alloc_increment0)
 
67
{
 
68
  init_dynamic_array2(this, element_size, init_alloc, alloc_increment0);
72
69
}
73
70
 
74
71
/*
84
81
    false       Ok
85
82
*/
86
83
 
87
 
static void insert_dynamic(DYNAMIC_ARRAY *array, void* element)
 
84
static void insert_dynamic(DYNAMIC_ARRAY* array, void* element)
88
85
{
89
86
  unsigned char* buffer;
90
87
  if (array->size() == array->max_element)
91
 
    buffer= alloc_dynamic(array);
 
88
    buffer= array->alloc();
92
89
  else
93
90
  {
94
91
    buffer= array->buffer+(array->size() * array->size_of_element);
120
117
    0           Error
121
118
*/
122
119
 
123
 
unsigned char *alloc_dynamic(DYNAMIC_ARRAY *array)
 
120
static unsigned char* alloc_dynamic(DYNAMIC_ARRAY* array)
124
121
{
125
122
  if (array->size() == array->max_element)
126
123
  {
127
 
    char *new_ptr;
128
 
    if (array->buffer == (unsigned char *)(array + 1))
 
124
    char* new_ptr;
 
125
    if (array->buffer == (unsigned char*)(array + 1))
129
126
    {
130
127
      /*
131
128
        In this senerio, the buffer is statically preallocated,
143
140
  return array->buffer + ((array->size() - 1) * array->size_of_element);
144
141
}
145
142
 
 
143
unsigned char* DYNAMIC_ARRAY::alloc()
 
144
{
 
145
  return alloc_dynamic(this);
 
146
}
 
147
 
146
148
/*
147
149
  Empty array by freeing all memory
148
150
 
151
153
      array     Array to be deleted
152
154
*/
153
155
 
154
 
void delete_dynamic(DYNAMIC_ARRAY *array)
 
156
static void delete_dynamic(DYNAMIC_ARRAY* array)
155
157
{
156
158
  /*
157
159
    Just mark as empty if we are using a static buffer
158
160
  */
159
 
  if (array->buffer == (unsigned char *)(array + 1))
 
161
  if (array->buffer == (unsigned char*)(array + 1))
160
162
    array->set_size(0);
161
 
  else
162
 
  if (array->buffer)
 
163
  else if (array->buffer)
163
164
  {
164
165
    free(array->buffer);
165
166
    array->buffer=0;
167
168
  }
168
169
}
169
170
 
 
171
void DYNAMIC_ARRAY::free()
 
172
{
 
173
  delete_dynamic(this);
 
174
}
 
175
 
170
176
} /* namespace drizzled */