← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/tree.cc

Moved the last of the libdrizzleclient calls into Protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/tree.cc
84
84
  memset(&tree->null_element, 0, sizeof(tree->null_element));
85
85
  tree->root= &tree->null_element;
86
86
  tree->compare=compare;
87
 
  tree->size_of_element=size > 0 ? (uint) size : 0;
 
87
  tree->size_of_element=size > 0 ? (uint32_t) size : 0;
88
88
  tree->memory_limit=memory_limit;
89
89
  tree->free=free_element;
90
90
  tree->allocated=0;
94
94
  tree->null_element.left=tree->null_element.right=0;
95
95
  tree->flag= 0;
96
96
  if (!free_element && size >= 0 &&
97
 
      ((uint) size <= sizeof(void*) || ((uint) size & (sizeof(void*)-1))))
 
97
      ((uint32_t) size <= sizeof(void*) || ((uint32_t) size & (sizeof(void*)-1))))
98
98
  {
99
99
    /*
100
100
      We know that the data doesn't have to be aligned (like if the key
115
115
  }
116
116
  if (!(tree->with_delete=with_delete))
117
117
  {
118
 
    init_alloc_root(&tree->mem_root, (uint) default_alloc_size, 0);
 
118
    init_alloc_root(&tree->mem_root, (uint32_t) default_alloc_size, 0);
119
119
    tree->mem_root.min_malloc=(sizeof(TREE_ELEMENT)+tree->size_of_element);
120
120
  }
121
121
  return;
181
181
    parent[0] = & parent[-1][0]->right
182
182
*/
183
183
 
184
 
TREE_ELEMENT *tree_insert(TREE *tree, void *key, uint32_t key_size, 
 
184
TREE_ELEMENT *tree_insert(TREE *tree, void *key, uint32_t key_size,
185
185
                          void* custom_arg)
186
186
{
187
187
  int cmp;
218
218
 
219
219
    key_size+=tree->size_of_element;
220
220
    if (tree->with_delete)
221
 
      element=(TREE_ELEMENT *) my_malloc(alloc_size, MYF(MY_WME));
 
221
      element=(TREE_ELEMENT *) malloc(alloc_size);
222
222
    else
223
223
      element=(TREE_ELEMENT *) alloc_root(&tree->mem_root,alloc_size);
224
224
    if (!element)
334
334
  }
335
335
}
336
336
 
337
 
void *tree_search_key(TREE *tree, const void *key, 
 
337
void *tree_search_key(TREE *tree, const void *key,
338
338
                      TREE_ELEMENT **parents, TREE_ELEMENT ***last_pos,
339
339
                      enum ha_rkey_function flag, void *custom_arg)
340
340
{
343
343
  TREE_ELEMENT **last_left_step_parent= NULL, **last_right_step_parent= NULL;
344
344
  TREE_ELEMENT **last_equal_element= NULL;
345
345
 
346
 
/* 
 
346
/*
347
347
  TODO: support for HA_READ_KEY_OR_PREV, HA_READ_PREFIX flags if needed.
348
348
*/
349
349
 
351
351
  while (element != &tree->null_element)
352
352
  {
353
353
    *++parents= element;
354
 
    if ((cmp= (*tree->compare)(custom_arg, ELEMENT_KEY(tree, element), 
 
354
    if ((cmp= (*tree->compare)(custom_arg, ELEMENT_KEY(tree, element),
355
355
                               key)) == 0)
356
356
    {
357
357
      switch (flag) {
407
407
  return *last_pos ? ELEMENT_KEY(tree, **last_pos) : NULL;
408
408
}
409
409
 
410
 
/* 
411
 
  Search first (the most left) or last (the most right) tree element 
 
410
/*
 
411
  Search first (the most left) or last (the most right) tree element
412
412
*/
413
 
void *tree_search_edge(TREE *tree, TREE_ELEMENT **parents, 
 
413
void *tree_search_edge(TREE *tree, TREE_ELEMENT **parents,
414
414
                       TREE_ELEMENT ***last_pos, int child_offs)
415
415
{
416
416
  TREE_ELEMENT *element= tree->root;
417
 
  
 
417
 
418
418
  *parents= &tree->null_element;
419
419
  while (element != &tree->null_element)
420
420
  {
422
422
    element= ELEMENT_CHILD(element, child_offs);
423
423
  }
424
424
  *last_pos= parents;
425
 
  return **last_pos != &tree->null_element ? 
 
425
  return **last_pos != &tree->null_element ?
426
426
    ELEMENT_KEY(tree, **last_pos) : NULL;
427
427
}
428
428
 
429
 
void *tree_search_next(TREE *tree, TREE_ELEMENT ***last_pos, int l_offs, 
 
429
void *tree_search_next(TREE *tree, TREE_ELEMENT ***last_pos, int l_offs,
430
430
                       int r_offs)
431
431
{
432
432
  TREE_ELEMENT *x= **last_pos;
433
 
  
 
433
 
434
434
  if (ELEMENT_CHILD(x, r_offs) != &tree->null_element)
435
435
  {
436
436
    x= ELEMENT_CHILD(x, r_offs);
458
458
  Expected that tree is fully balanced
459
459
  (each path from root to leaf has the same length)
460
460
*/
461
 
ha_rows tree_record_pos(TREE *tree, const void *key, 
 
461
ha_rows tree_record_pos(TREE *tree, const void *key,
462
462
                        enum ha_rkey_function flag, void *custom_arg)
463
463
{
464
464
  int cmp;
468
468
 
469
469
  while (element != &tree->null_element)
470
470
  {
471
 
    if ((cmp= (*tree->compare)(custom_arg, ELEMENT_KEY(tree, element), 
 
471
    if ((cmp= (*tree->compare)(custom_arg, ELEMENT_KEY(tree, element),
472
472
                               key)) == 0)
473
473
    {
474
474
      switch (flag) {