← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/ut/ut0list.c

  • Committer: Monty Taylor
  • Date: 2009-08-12 06:25:19 UTC
  • mto: (1114.1.1 innodb-plugin-merge)
  • mto: This revision was merged to the branch mainline in revision 1183.
  • Revision ID: mordred@inaugust.com-20090812062519-cij02mrrunvnxblt
Tags: innodb-plugin-1.0.4
InnoDB Plugin 1.0.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/ut/ut0list.c
16
16
 
17
17
*****************************************************************************/
18
18
 
 
19
/*******************************************************************//**
 
20
@file ut/ut0list.c
 
21
A double-linked list
 
22
 
 
23
Created 4/26/2006 Osku Salerma
 
24
************************************************************************/
 
25
 
19
26
#include "ut0list.h"
20
27
#ifdef UNIV_NONINL
21
28
#include "ut0list.ic"
22
29
#endif
23
30
 
24
 
/********************************************************************
25
 
Create a new list. */
 
31
/****************************************************************//**
 
32
Create a new list.
 
33
@return list */
26
34
UNIV_INTERN
27
35
ib_list_t*
28
36
ib_list_create(void)
29
37
/*=================*/
30
 
                        /* out: list */
31
38
{
32
39
        ib_list_t*      list = mem_alloc(sizeof(ib_list_t));
33
40
 
38
45
        return(list);
39
46
}
40
47
 
41
 
/********************************************************************
 
48
/****************************************************************//**
42
49
Create a new list using the given heap. ib_list_free MUST NOT BE CALLED for
43
 
lists created with this function. */
 
50
lists created with this function.
 
51
@return list */
44
52
UNIV_INTERN
45
53
ib_list_t*
46
54
ib_list_create_heap(
47
55
/*================*/
48
 
                                /* out: list */
49
 
        mem_heap_t*     heap)   /* in: memory heap to use */
 
56
        mem_heap_t*     heap)   /*!< in: memory heap to use */
50
57
{
51
58
        ib_list_t*      list = mem_heap_alloc(heap, sizeof(ib_list_t));
52
59
 
57
64
        return(list);
58
65
}
59
66
 
60
 
/********************************************************************
 
67
/****************************************************************//**
61
68
Free a list. */
62
69
UNIV_INTERN
63
70
void
64
71
ib_list_free(
65
72
/*=========*/
66
 
        ib_list_t*      list)   /* in: list */
 
73
        ib_list_t*      list)   /*!< in: list */
67
74
{
68
75
        ut_a(!list->is_heap_list);
69
76
 
74
81
        mem_free(list);
75
82
}
76
83
 
77
 
/********************************************************************
78
 
Add the data to the start of the list. */
 
84
/****************************************************************//**
 
85
Add the data to the start of the list.
 
86
@return new list node */
79
87
UNIV_INTERN
80
88
ib_list_node_t*
81
89
ib_list_add_first(
82
90
/*==============*/
83
 
                                /* out: new list node*/
84
 
        ib_list_t*      list,   /* in: list */
85
 
        void*           data,   /* in: data */
86
 
        mem_heap_t*     heap)   /* in: memory heap to use */
 
91
        ib_list_t*      list,   /*!< in: list */
 
92
        void*           data,   /*!< in: data */
 
93
        mem_heap_t*     heap)   /*!< in: memory heap to use */
87
94
{
88
95
        return(ib_list_add_after(list, ib_list_get_first(list), data, heap));
89
96
}
90
97
 
91
 
/********************************************************************
92
 
Add the data to the end of the list. */
 
98
/****************************************************************//**
 
99
Add the data to the end of the list.
 
100
@return new list node */
93
101
UNIV_INTERN
94
102
ib_list_node_t*
95
103
ib_list_add_last(
96
104
/*=============*/
97
 
                                /* out: new list node*/
98
 
        ib_list_t*      list,   /* in: list */
99
 
        void*           data,   /* in: data */
100
 
        mem_heap_t*     heap)   /* in: memory heap to use */
 
105
        ib_list_t*      list,   /*!< in: list */
 
106
        void*           data,   /*!< in: data */
 
107
        mem_heap_t*     heap)   /*!< in: memory heap to use */
101
108
{
102
109
        return(ib_list_add_after(list, ib_list_get_last(list), data, heap));
103
110
}
104
111
 
105
 
/********************************************************************
106
 
Add the data after the indicated node. */
 
112
/****************************************************************//**
 
113
Add the data after the indicated node.
 
114
@return new list node */
107
115
UNIV_INTERN
108
116
ib_list_node_t*
109
117
ib_list_add_after(
110
118
/*==============*/
111
 
                                        /* out: new list node*/
112
 
        ib_list_t*      list,           /* in: list */
113
 
        ib_list_node_t* prev_node,      /* in: node preceding new node (can
 
119
        ib_list_t*      list,           /*!< in: list */
 
120
        ib_list_node_t* prev_node,      /*!< in: node preceding new node (can
114
121
                                        be NULL) */
115
 
        void*           data,           /* in: data */
116
 
        mem_heap_t*     heap)           /* in: memory heap to use */
 
122
        void*           data,           /*!< in: data */
 
123
        mem_heap_t*     heap)           /*!< in: memory heap to use */
117
124
{
118
125
        ib_list_node_t* node = mem_heap_alloc(heap, sizeof(ib_list_node_t));
119
126
 
156
163
        return(node);
157
164
}
158
165
 
159
 
/********************************************************************
 
166
/****************************************************************//**
160
167
Remove the node from the list. */
161
168
UNIV_INTERN
162
169
void
163
170
ib_list_remove(
164
171
/*===========*/
165
 
        ib_list_t*      list,   /* in: list */
166
 
        ib_list_node_t* node)   /* in: node to remove */
 
172
        ib_list_t*      list,   /*!< in: list */
 
173
        ib_list_node_t* node)   /*!< in: node to remove */
167
174
{
168
175
        if (node->prev) {
169
176
                node->prev->next = node->next;