← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/dynamic_array.cc

  • Committer: pcrews
  • Date: 2011-05-24 17:36:24 UTC
  • mfrom: (1099.4.232 drizzle)
  • Revision ID: pcrews@lucid32-20110524173624-mwr1bvq6fa1r01ao
Updated translations + 2011.05.18 tarball tag

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/dynamic_array.cc
15
15
 
16
16
/* Handling of arrays that can grow dynamicly. */
17
17
 
18
 
#include "config.h"
19
 
#include "drizzled/internal/my_sys.h"
20
 
#include "drizzled/internal/m_string.h"
21
 
 
 
18
#include <config.h>
22
19
#include <algorithm>
 
20
#include <drizzled/dynamic_array.h>
 
21
#include <drizzled/internal/my_sys.h>
23
22
 
24
23
using namespace std;
25
24
 
26
 
namespace drizzled
27
 
{
28
 
 
29
 
static bool allocate_dynamic(DYNAMIC_ARRAY *array, uint32_t max_elements);
 
25
namespace drizzled {
30
26
 
31
27
/*
32
28
  Initiate dynamic array
66
62
    init_alloc=alloc_increment;
67
63
    init_buffer= 0;
68
64
  }
69
 
  array->elements=0;
 
65
  array->set_size(0);
70
66
  array->max_element=init_alloc;
71
67
  array->alloc_increment=alloc_increment;
72
68
  array->size_of_element=element_size;
93
89
    false       Ok
94
90
*/
95
91
 
96
 
bool insert_dynamic(DYNAMIC_ARRAY *array, unsigned char* element)
 
92
static void insert_dynamic(DYNAMIC_ARRAY *array, void* element)
97
93
{
98
94
  unsigned char* buffer;
99
 
  if (array->elements == array->max_element)
100
 
  {                                             /* Call only when nessesary */
101
 
    if (!(buffer=alloc_dynamic(array)))
102
 
      return true;
103
 
  }
 
95
  if (array->size() == array->max_element)
 
96
    buffer= alloc_dynamic(array);
104
97
  else
105
98
  {
106
 
    buffer=array->buffer+(array->elements * array->size_of_element);
107
 
    array->elements++;
 
99
    buffer= array->buffer+(array->size() * array->size_of_element);
 
100
    array->set_size(array->size() + 1);
108
101
  }
109
 
  memcpy(buffer,element,(size_t) array->size_of_element);
110
 
  return false;
 
102
  memcpy(buffer,element, array->size_of_element);
 
103
}
 
104
 
 
105
void DYNAMIC_ARRAY::push_back(void* v)
 
106
{
 
107
  insert_dynamic(this, v);
111
108
}
112
109
 
113
110
 
130
127
 
131
128
unsigned char *alloc_dynamic(DYNAMIC_ARRAY *array)
132
129
{
133
 
  if (array->elements == array->max_element)
 
130
  if (array->size() == array->max_element)
134
131
  {
135
132
    char *new_ptr;
136
133
    if (array->buffer == (unsigned char *)(array + 1))
144
141
                                     array->size_of_element)))
145
142
        return 0;
146
143
      memcpy(new_ptr, array->buffer,
147
 
             array->elements * array->size_of_element);
 
144
             array->size() * array->size_of_element);
148
145
    }
149
146
    else if (!(new_ptr= (char*) realloc(array->buffer,
150
147
                                        (array->max_element+
154
151
    array->buffer= (unsigned char*) new_ptr;
155
152
    array->max_element+=array->alloc_increment;
156
153
  }
157
 
  return array->buffer+(array->elements++ * array->size_of_element);
158
 
}
159
 
 
160
 
 
161
 
/*
162
 
  Pop last element from array.
163
 
 
164
 
  SYNOPSIS
165
 
    pop_dynamic()
166
 
      array
167
 
 
168
 
  RETURN VALUE
169
 
    pointer     Ok
170
 
    0           Array is empty
171
 
*/
172
 
 
173
 
unsigned char *pop_dynamic(DYNAMIC_ARRAY *array)
174
 
{
175
 
  if (array->elements)
176
 
    return array->buffer+(--array->elements * array->size_of_element);
177
 
  return 0;
178
 
}
179
 
 
180
 
/*
181
 
  Replace element in array with given element and index
182
 
 
183
 
  SYNOPSIS
184
 
    set_dynamic()
185
 
      array
186
 
      element   Element to be inserted
187
 
      idx       Index where element is to be inserted
188
 
 
189
 
  DESCRIPTION
190
 
    set_dynamic() replaces element in array.
191
 
    If idx > max_element insert new element. Allocate memory if needed.
192
 
 
193
 
  RETURN VALUE
194
 
    true        Idx was out of range and allocation of new memory failed
195
 
    false       Ok
196
 
*/
197
 
 
198
 
bool set_dynamic(DYNAMIC_ARRAY *array, unsigned char* element, uint32_t idx)
199
 
{
200
 
  if (idx >= array->elements)
201
 
  {
202
 
    if (idx >= array->max_element && allocate_dynamic(array, idx))
203
 
      return true;
204
 
    memset(array->buffer+array->elements*array->size_of_element, 0,
205
 
           (idx - array->elements)*array->size_of_element);
206
 
    array->elements=idx+1;
207
 
  }
208
 
  memcpy(array->buffer+(idx * array->size_of_element),element,
209
 
         (size_t) array->size_of_element);
210
 
  return false;
211
 
}
212
 
 
213
 
 
214
 
/*
215
 
  Ensure that dynamic array has enough elements
216
 
 
217
 
  SYNOPSIS
218
 
    allocate_dynamic()
219
 
    array
220
 
    max_elements        Numbers of elements that is needed
221
 
 
222
 
  NOTES
223
 
   Any new allocated element are NOT initialized
224
 
 
225
 
  RETURN VALUE
226
 
    false       Ok
227
 
    true        Allocation of new memory failed
228
 
*/
229
 
 
230
 
static bool allocate_dynamic(DYNAMIC_ARRAY *array, uint32_t max_elements)
231
 
{
232
 
  if (max_elements >= array->max_element)
233
 
  {
234
 
    uint32_t size;
235
 
    unsigned char *new_ptr;
236
 
    size= (max_elements + array->alloc_increment)/array->alloc_increment;
237
 
    size*= array->alloc_increment;
238
 
    if (array->buffer == (unsigned char *)(array + 1))
239
 
    {
240
 
       /*
241
 
         In this senerio, the buffer is statically preallocated,
242
 
         so we have to create an all-new malloc since we overflowed
243
 
       */
244
 
       if (!(new_ptr= (unsigned char *) malloc(size *
245
 
                                               array->size_of_element)))
246
 
         return 0;
247
 
       memcpy(new_ptr, array->buffer,
248
 
              array->elements * array->size_of_element);
249
 
     }
250
 
     else
251
 
 
252
 
 
253
 
    if (!(new_ptr=(unsigned char*) realloc(array->buffer,
254
 
                                        size* array->size_of_element)))
255
 
      return true;
256
 
    array->buffer= new_ptr;
257
 
    array->max_element= size;
258
 
  }
259
 
  return false;
260
 
}
261
 
 
262
 
 
263
 
/*
264
 
  Get an element from array by given index
265
 
 
266
 
  SYNOPSIS
267
 
    get_dynamic()
268
 
      array
269
 
      unsigned char*    Element to be returned. If idx > elements contain zeroes.
270
 
      idx       Index of element wanted.
271
 
*/
272
 
 
273
 
void get_dynamic(DYNAMIC_ARRAY *array, unsigned char* element, uint32_t idx)
274
 
{
275
 
  if (idx >= array->elements)
276
 
  {
277
 
    memset(element, 0, array->size_of_element);
278
 
    return;
279
 
  }
280
 
  memcpy(element,array->buffer+idx*array->size_of_element,
281
 
         (size_t) array->size_of_element);
282
 
}
283
 
 
 
154
  array->set_size(array->size() + 1);
 
155
  return array->buffer + ((array->size() - 1) * array->size_of_element);
 
156
}
284
157
 
285
158
/*
286
159
  Empty array by freeing all memory
296
169
    Just mark as empty if we are using a static buffer
297
170
  */
298
171
  if (array->buffer == (unsigned char *)(array + 1))
299
 
    array->elements= 0;
 
172
    array->set_size(0);
300
173
  else
301
174
  if (array->buffer)
302
175
  {
303
176
    free(array->buffer);
304
177
    array->buffer=0;
305
 
    array->elements=array->max_element=0;
 
178
    array->set_size(array->max_element=0);
306
179
  }
307
180
}
308
181