← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/dynamic_array.cc

  • Committer: Eric Day
  • Date: 2009-08-27 07:26:22 UTC
  • mto: This revision was merged to the branch mainline in revision 1131.
  • Revision ID: eday@oddments.org-20090827072622-72te13ua0wdlc2ky
Reworked listen interface to not require binding of TCP ports.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/dynamic_array.cc
15
15
 
16
16
/* Handling of arrays that can grow dynamicly. */
17
17
 
18
 
#include "mysys_priv.h"
 
18
#include "mysys/mysys_priv.h"
19
19
#include <mystrings/m_string.h>
20
20
 
 
21
#include <algorithm>
 
22
 
 
23
using namespace std;
 
24
 
21
25
/*
22
26
  Initiate dynamic array
23
27
 
30
34
      alloc_increment   Increment for adding new elements
31
35
 
32
36
  DESCRIPTION
33
 
    init_dynamic_array() initiates array and allocate space for 
34
 
    init_alloc eilements. 
 
37
    init_dynamic_array() initiates array and allocate space for
 
38
    init_alloc eilements.
35
39
    Array is usable even if space allocation failed.
36
40
    Static buffers must begin immediately after the array structure.
37
41
 
38
42
  RETURN VALUE
39
 
    true        my_malloc_ci() failed
 
43
    true        malloc() failed
40
44
    false       Ok
41
45
*/
42
46
 
43
47
bool init_dynamic_array2(DYNAMIC_ARRAY *array, uint32_t element_size,
44
 
                            void *init_buffer, uint32_t init_alloc, 
45
 
                            uint32_t alloc_increment CALLER_INFO_PROTO)
 
48
                            void *init_buffer, uint32_t init_alloc,
 
49
                            uint32_t alloc_increment)
46
50
{
47
51
  if (!alloc_increment)
48
52
  {
49
 
    alloc_increment=cmax((8192-MALLOC_OVERHEAD)/element_size,16);
 
53
    alloc_increment=max((8192-MALLOC_OVERHEAD)/element_size,16U);
50
54
    if (init_alloc > 8 && alloc_increment > init_alloc * 2)
51
55
      alloc_increment=init_alloc*2;
52
56
  }
60
64
  array->max_element=init_alloc;
61
65
  array->alloc_increment=alloc_increment;
62
66
  array->size_of_element=element_size;
63
 
  if ((array->buffer= init_buffer))
 
67
  if ((array->buffer= (unsigned char*) init_buffer))
64
68
    return(false);
65
 
  if (!(array->buffer=(unsigned char*) my_malloc_ci(element_size*init_alloc,
66
 
                                            MYF(MY_WME))))
 
69
  if (!(array->buffer=(unsigned char*) malloc(element_size*init_alloc)))
67
70
  {
68
71
    array->max_element=0;
69
72
    return(true);
70
73
  }
71
74
  return(false);
72
 
} 
 
75
}
73
76
 
74
 
bool init_dynamic_array(DYNAMIC_ARRAY *array, uint32_t element_size,
75
 
                           uint32_t init_alloc, 
76
 
                           uint32_t alloc_increment CALLER_INFO_PROTO)
77
 
{
78
 
  /* placeholder to preserve ABI */
79
 
  return my_init_dynamic_array_ci(array, element_size, init_alloc, 
80
 
                                  alloc_increment);
81
 
}
82
77
/*
83
78
  Insert element at the end of array. Allocate memory if needed.
84
79
 
111
106
 
112
107
 
113
108
/*
114
 
  Alloc space for next element(s) 
 
109
  Alloc space for next element(s)
115
110
 
116
111
  SYNOPSIS
117
112
    alloc_dynamic()
138
133
        In this senerio, the buffer is statically preallocated,
139
134
        so we have to create an all-new malloc since we overflowed
140
135
      */
141
 
      if (!(new_ptr= (char *) my_malloc((array->max_element+
142
 
                                         array->alloc_increment) *
143
 
                                        array->size_of_element,
144
 
                                        MYF(MY_WME))))
 
136
      if (!(new_ptr= (char *) malloc((array->max_element+
 
137
                                     array->alloc_increment) *
 
138
                                     array->size_of_element)))
145
139
        return 0;
146
 
      memcpy(new_ptr, array->buffer, 
 
140
      memcpy(new_ptr, array->buffer,
147
141
             array->elements * array->size_of_element);
148
142
    }
149
 
    else
150
 
    if (!(new_ptr=(char*) my_realloc(array->buffer,(array->max_element+
151
 
                                     array->alloc_increment)*
152
 
                                     array->size_of_element,
153
 
                                     MYF(MY_WME | MY_ALLOW_ZERO_PTR))))
 
143
    else if (!(new_ptr= (char*) realloc(array->buffer,
 
144
                                        (array->max_element+
 
145
                                         array->alloc_increment)*
 
146
                                        array->size_of_element)))
154
147
      return 0;
155
148
    array->buffer= (unsigned char*) new_ptr;
156
149
    array->max_element+=array->alloc_increment;
165
158
  SYNOPSIS
166
159
    pop_dynamic()
167
160
      array
168
 
  
169
 
  RETURN VALUE    
 
161
 
 
162
  RETURN VALUE
170
163
    pointer     Ok
171
164
    0           Array is empty
172
165
*/
188
181
      idx       Index where element is to be inserted
189
182
 
190
183
  DESCRIPTION
191
 
    set_dynamic() replaces element in array. 
192
 
    If idx > max_element insert new element. Allocate memory if needed. 
193
 
 
 
184
    set_dynamic() replaces element in array.
 
185
    If idx > max_element insert new element. Allocate memory if needed.
 
186
 
194
187
  RETURN VALUE
195
188
    true        Idx was out of range and allocation of new memory failed
196
189
    false       Ok
242
235
         In this senerio, the buffer is statically preallocated,
243
236
         so we have to create an all-new malloc since we overflowed
244
237
       */
245
 
       if (!(new_ptr= (unsigned char *) my_malloc(size *
246
 
                                         array->size_of_element,
247
 
                                         MYF(MY_WME))))
 
238
       if (!(new_ptr= (unsigned char *) malloc(size *
 
239
                                               array->size_of_element)))
248
240
         return 0;
249
 
       memcpy(new_ptr, array->buffer, 
 
241
       memcpy(new_ptr, array->buffer,
250
242
              array->elements * array->size_of_element);
251
243
     }
252
244
     else
253
245
 
254
246
 
255
 
    if (!(new_ptr= (unsigned char*) my_realloc(array->buffer,size*
256
 
                                       array->size_of_element,
257
 
                                       MYF(MY_WME | MY_ALLOW_ZERO_PTR))))
 
247
    if (!(new_ptr=(unsigned char*) realloc(array->buffer,
 
248
                                        size* array->size_of_element)))
258
249
      return true;
259
250
    array->buffer= new_ptr;
260
251
    array->max_element= size;
268
259
 
269
260
  SYNOPSIS
270
261
    get_dynamic()
271
 
      array     
 
262
      array
272
263
      unsigned char*    Element to be returned. If idx > elements contain zeroes.
273
 
      idx       Index of element wanted. 
 
264
      idx       Index of element wanted.
274
265
*/
275
266
 
276
267
void get_dynamic(DYNAMIC_ARRAY *array, unsigned char* element, uint32_t idx)
308
299
    array->elements=array->max_element=0;
309
300
  }
310
301
}
311
 
 
312
 
/*
313
 
  Delete element by given index
314
 
 
315
 
  SYNOPSIS
316
 
    delete_dynamic_element()
317
 
      array
318
 
      idx        Index of element to be deleted
319
 
*/
320
 
 
321
 
void delete_dynamic_element(DYNAMIC_ARRAY *array, uint32_t idx)
322
 
{
323
 
  char *ptr= (char*) array->buffer+array->size_of_element*idx;
324
 
  array->elements--;
325
 
  memmove(ptr,ptr+array->size_of_element,
326
 
          (array->elements-idx)*array->size_of_element);
327
 
}
328
 
 
329
 
 
330
 
/*
331
 
  Free unused memory
332
 
 
333
 
  SYNOPSIS
334
 
    freeze_size()
335
 
      array     Array to be freed
336
 
 
337
 
*/
338
 
 
339
 
void freeze_size(DYNAMIC_ARRAY *array)
340
 
{
341
 
  uint32_t elements=cmax(array->elements,1);
342
 
 
343
 
  /*
344
 
    Do nothing if we are using a static buffer
345
 
  */
346
 
  if (array->buffer == (unsigned char *)(array + 1))
347
 
    return;
348
 
    
349
 
  if (array->buffer && array->max_element != elements)
350
 
  {
351
 
    array->buffer=(unsigned char*) my_realloc(array->buffer,
352
 
                                     elements*array->size_of_element,
353
 
                                     MYF(MY_WME));
354
 
    array->max_element=elements;
355
 
  }
356
 
}
357
 
 
358
 
 
359
 
/*
360
 
  Get the index of a dynamic element
361
 
 
362
 
  SYNOPSIS
363
 
    get_index_dynamic()
364
 
     array      Array
365
 
     element Whose element index 
366
 
 
367
 
*/
368
 
 
369
 
int get_index_dynamic(DYNAMIC_ARRAY *array, unsigned char* element)
370
 
{
371
 
  uint32_t ret;
372
 
  if (array->buffer > element)
373
 
    return -1;
374
 
 
375
 
  ret= (element - array->buffer) /  array->size_of_element;
376
 
  if (ret > array->elements)
377
 
    return -1;
378
 
 
379
 
  return ret;
380
 
 
381
 
}