← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/include/ut0lst.h

  • Committer: Brian Aker
  • Date: 2011-02-22 06:12:02 UTC
  • mfrom: (2190.1.6 drizzle-build)
  • Revision ID: brian@tangent.org-20110222061202-k03czxykqy4x9hjs
List update, header fixes, multiple symbols, and David deletes some code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/ut0lst.h
1
 
/**********************************************************************
 
1
/*****************************************************************************
 
2
 
 
3
Copyright (C) 1995, 2010, Innobase Oy. All Rights Reserved.
 
4
 
 
5
This program is free software; you can redistribute it and/or modify it under
 
6
the terms of the GNU General Public License as published by the Free Software
 
7
Foundation; version 2 of the License.
 
8
 
 
9
This program is distributed in the hope that it will be useful, but WITHOUT
 
10
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 
11
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 
12
 
 
13
You should have received a copy of the GNU General Public License along with
 
14
this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
 
15
St, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
*****************************************************************************/
 
18
 
 
19
/******************************************************************//**
 
20
@file include/ut0lst.h
2
21
List utilities
3
22
 
4
 
(c) 1995 Innobase Oy
5
 
 
6
23
Created 9/10/1995 Heikki Tuuri
7
24
***********************************************************************/
8
25
 
16
33
to two or more lists, provided that the list are given different names.
17
34
An example of the usage of the lists can be found in fil0fil.c. */
18
35
 
19
 
/***********************************************************************
 
36
/*******************************************************************//**
20
37
This macro expands to the unnamed type definition of a struct which acts
21
38
as the two-way list base node. The base node contains pointers
22
39
to both ends of the list and a count of nodes in the list (excluding
23
 
the base node from the count). TYPE should be the list node type name. */
24
 
 
25
 
#define UT_LIST_BASE_NODE_T(TYPE)\
26
 
struct {\
27
 
        ulint   count;  /* count of nodes in list */\
28
 
        TYPE *  start;  /* pointer to list start, NULL if empty */\
29
 
        TYPE *  end;    /* pointer to list end, NULL if empty */\
30
 
}\
31
 
 
32
 
/***********************************************************************
 
40
the base node from the count).
 
41
@param TYPE     the name of the list node data type */
 
42
#ifdef __cplusplus
 
43
template<class T>
 
44
class ut_list_base_node
 
45
{
 
46
public:
 
47
  size_t count; /*!< count of nodes in list */\
 
48
  T *   start;  /*!< pointer to list start, NULL if empty */\
 
49
  T *   end;    /*!< pointer to list end, NULL if empty */\
 
50
};
 
51
#define UT_LIST_BASE_NODE_T(TYPE) ut_list_base_node<TYPE>
 
52
#else
 
53
#define UT_LIST_BASE_NODE_T(TYPE) int
 
54
#endif
 
55
 
 
56
/*******************************************************************//**
33
57
This macro expands to the unnamed type definition of a struct which
34
58
should be embedded in the nodes of the list, the node type must be a struct.
35
59
This struct contains the pointers to next and previous nodes in the list.
36
60
The name of the field in the node struct should be the name given
37
 
to the list. TYPE should be the list node type name. Example of usage:
38
 
 
 
61
to the list.
 
62
@param TYPE     the list node type name */
 
63
/* Example:
39
64
typedef struct LRU_node_struct  LRU_node_t;
40
65
struct LRU_node_struct {
41
66
        UT_LIST_NODE_T(LRU_node_t)      LRU_list;
42
67
        ...
43
68
}
44
69
The example implements an LRU list of name LRU_list. Its nodes are of type
45
 
LRU_node_t.
46
 
*/
 
70
LRU_node_t. */
47
71
 
48
72
#define UT_LIST_NODE_T(TYPE)\
49
73
struct {\
50
 
        TYPE *  prev;   /* pointer to the previous node,\
 
74
        TYPE *  prev;   /*!< pointer to the previous node,\
51
75
                        NULL if start of list */\
52
 
        TYPE *  next;   /* pointer to next node, NULL if end of list */\
 
76
        TYPE *  next;   /*!< pointer to next node, NULL if end of list */\
53
77
}\
54
78
 
55
 
/***********************************************************************
56
 
Initializes the base node of a two-way list. */
57
 
 
 
79
/*******************************************************************//**
 
80
Initializes the base node of a two-way list.
 
81
@param BASE     the list base node
 
82
*/
58
83
#define UT_LIST_INIT(BASE)\
59
84
{\
60
85
        (BASE).count = 0;\
62
87
        (BASE).end   = NULL;\
63
88
}\
64
89
 
65
 
/***********************************************************************
 
90
/*******************************************************************//**
66
91
Adds the node as the first element in a two-way linked list.
67
 
BASE has to be the base node (not a pointer to it). N has to be
68
 
the pointer to the node to be added to the list. NAME is the list name. */
69
 
 
 
92
@param NAME     list name
 
93
@param BASE     the base node (not a pointer to it)
 
94
@param N        pointer to the node to be added to the list.
 
95
*/
70
96
#define UT_LIST_ADD_FIRST(NAME, BASE, N)\
71
97
{\
72
98
        ut_ad(N);\
83
109
        }\
84
110
}\
85
111
 
86
 
/***********************************************************************
 
112
/*******************************************************************//**
87
113
Adds the node as the last element in a two-way linked list.
88
 
BASE has to be the base node (not a pointer to it). N has to be
89
 
the pointer to the node to be added to the list. NAME is the list name. */
90
 
 
 
114
@param NAME     list name
 
115
@param BASE     the base node (not a pointer to it)
 
116
@param N        pointer to the node to be added to the list
 
117
*/
91
118
#define UT_LIST_ADD_LAST(NAME, BASE, N)\
92
119
{\
93
 
        ut_ad(N);\
 
120
        ut_ad(N != NULL);\
94
121
        ((BASE).count)++;\
95
122
        ((N)->NAME).prev = (BASE).end;\
96
123
        ((N)->NAME).next = NULL;\
104
131
        }\
105
132
}\
106
133
 
107
 
/***********************************************************************
 
134
/*******************************************************************//**
108
135
Inserts a NODE2 after NODE1 in a list.
109
 
BASE has to be the base node (not a pointer to it). NAME is the list
110
 
name, NODE1 and NODE2 are pointers to nodes. */
111
 
 
 
136
@param NAME     list name
 
137
@param BASE     the base node (not a pointer to it)
 
138
@param NODE1    pointer to node after which NODE2 is inserted
 
139
@param NODE2    pointer to node being inserted after NODE1
 
140
*/
112
141
#define UT_LIST_INSERT_AFTER(NAME, BASE, NODE1, NODE2)\
113
142
{\
114
143
        ut_ad(NODE1);\
126
155
        }\
127
156
}\
128
157
 
129
 
/* Invalidate the pointers in a list node. */
130
158
#ifdef UNIV_LIST_DEBUG
 
159
/** Invalidate the pointers in a list node.
 
160
@param NAME     list name
 
161
@param N        pointer to the node that was removed */
131
162
# define UT_LIST_REMOVE_CLEAR(NAME, N)          \
132
163
((N)->NAME.prev = (N)->NAME.next = (void*) -1)
133
164
#else
134
 
# define UT_LIST_REMOVE_CLEAR(NAME, N) while (0)
 
165
/** Invalidate the pointers in a list node.
 
166
@param NAME     list name
 
167
@param N        pointer to the node that was removed */
 
168
# define UT_LIST_REMOVE_CLEAR(NAME, N)
135
169
#endif
136
170
 
137
 
/***********************************************************************
138
 
Removes a node from a two-way linked list. BASE has to be the base node
139
 
(not a pointer to it). N has to be the pointer to the node to be removed
140
 
from the list. NAME is the list name. */
141
 
 
 
171
/*******************************************************************//**
 
172
Removes a node from a two-way linked list.
 
173
@param NAME     list name
 
174
@param BASE     the base node (not a pointer to it)
 
175
@param N        pointer to the node to be removed from the list
 
176
*/
142
177
#define UT_LIST_REMOVE(NAME, BASE, N)                                   \
143
178
do {                                                                    \
144
179
        ut_ad(N);                                                       \
157
192
        UT_LIST_REMOVE_CLEAR(NAME, N);                                  \
158
193
} while (0)
159
194
 
160
 
/************************************************************************
161
 
Gets the next node in a two-way list. NAME is the name of the list
162
 
and N is pointer to a node. */
163
 
 
 
195
/********************************************************************//**
 
196
Gets the next node in a two-way list.
 
197
@param NAME     list name
 
198
@param N        pointer to a node
 
199
@return         the successor of N in NAME, or NULL */
164
200
#define UT_LIST_GET_NEXT(NAME, N)\
165
201
        (((N)->NAME).next)
166
202
 
167
 
/************************************************************************
168
 
Gets the previous node in a two-way list. NAME is the name of the list
169
 
and N is pointer to a node. */
170
 
 
 
203
/********************************************************************//**
 
204
Gets the previous node in a two-way list.
 
205
@param NAME     list name
 
206
@param N        pointer to a node
 
207
@return         the predecessor of N in NAME, or NULL */
171
208
#define UT_LIST_GET_PREV(NAME, N)\
172
209
        (((N)->NAME).prev)
173
210
 
174
 
/************************************************************************
 
211
/********************************************************************//**
175
212
Alternative macro to get the number of nodes in a two-way list, i.e.,
176
 
its length. BASE is the base node (not a pointer to it). */
177
 
 
 
213
its length.
 
214
@param BASE     the base node (not a pointer to it).
 
215
@return         the number of nodes in the list */
178
216
#define UT_LIST_GET_LEN(BASE)\
179
217
        (BASE).count
180
218
 
181
 
/************************************************************************
182
 
Gets the first node in a two-way list, or returns NULL,
183
 
if the list is empty. BASE is the base node (not a pointer to it). */
184
 
 
 
219
/********************************************************************//**
 
220
Gets the first node in a two-way list.
 
221
@param BASE     the base node (not a pointer to it)
 
222
@return         first node, or NULL if the list is empty */
185
223
#define UT_LIST_GET_FIRST(BASE)\
186
224
        (BASE).start
187
225
 
188
 
/************************************************************************
189
 
Gets the last node in a two-way list, or returns NULL,
190
 
if the list is empty. BASE is the base node (not a pointer to it). */
191
 
 
 
226
/********************************************************************//**
 
227
Gets the last node in a two-way list.
 
228
@param BASE     the base node (not a pointer to it)
 
229
@return         last node, or NULL if the list is empty */
 
230
#ifdef __cplusplus
192
231
#define UT_LIST_GET_LAST(BASE)\
193
232
        (BASE).end
194
 
 
195
 
/************************************************************************
196
 
Checks the consistency of a two-way list. NAME is the name of the list,
197
 
TYPE is the node type, and BASE is the base node (not a pointer to it). */
198
 
 
199
 
#define UT_LIST_VALIDATE(NAME, TYPE, BASE)\
200
 
{\
201
 
        ulint   ut_list_i_313;\
202
 
        TYPE *  ut_list_node_313;\
203
 
\
204
 
        ut_list_node_313 = (BASE).start;\
205
 
\
206
 
        for (ut_list_i_313 = 0; ut_list_i_313 < (BASE).count;\
207
 
                                                ut_list_i_313++) {\
208
 
                ut_a(ut_list_node_313);\
209
 
                ut_list_node_313 = (ut_list_node_313->NAME).next;\
210
 
        }\
211
 
\
212
 
        ut_a(ut_list_node_313 == NULL);\
213
 
\
214
 
        ut_list_node_313 = (BASE).end;\
215
 
\
216
 
        for (ut_list_i_313 = 0; ut_list_i_313 < (BASE).count;\
217
 
                                                ut_list_i_313++) {\
218
 
                ut_a(ut_list_node_313);\
219
 
                ut_list_node_313 = (ut_list_node_313->NAME).prev;\
220
 
        }\
221
 
\
222
 
        ut_a(ut_list_node_313 == NULL);\
223
 
}\
224
 
 
 
233
#else
 
234
#define UT_LIST_GET_LAST(BASE) (BASE= NULL)
 
235
#endif
 
236
 
 
237
/********************************************************************//**
 
238
Checks the consistency of a two-way list.
 
239
@param NAME             the name of the list
 
240
@param TYPE             node type
 
241
@param BASE             base node (not a pointer to it)
 
242
@param ASSERTION        a condition on ut_list_node_313 */
 
243
#define UT_LIST_VALIDATE(NAME, TYPE, BASE, ASSERTION)                   \
 
244
do {                                                                    \
 
245
        ulint   ut_list_i_313;                                          \
 
246
        TYPE*   ut_list_node_313;                                       \
 
247
                                                                        \
 
248
        ut_list_node_313 = (BASE).start;                                \
 
249
                                                                        \
 
250
        for (ut_list_i_313 = (BASE).count; ut_list_i_313--; ) {         \
 
251
                ut_a(ut_list_node_313);                                 \
 
252
                ASSERTION;                                              \
 
253
                ut_ad((ut_list_node_313->NAME).next || !ut_list_i_313); \
 
254
                ut_list_node_313 = (ut_list_node_313->NAME).next;       \
 
255
        }                                                               \
 
256
                                                                        \
 
257
        ut_a(ut_list_node_313 == NULL);                                 \
 
258
                                                                        \
 
259
        ut_list_node_313 = (BASE).end;                                  \
 
260
                                                                        \
 
261
        for (ut_list_i_313 = (BASE).count; ut_list_i_313--; ) {         \
 
262
                ut_a(ut_list_node_313);                                 \
 
263
                ASSERTION;                                              \
 
264
                ut_ad((ut_list_node_313->NAME).prev || !ut_list_i_313); \
 
265
                ut_list_node_313 = (ut_list_node_313->NAME).prev;       \
 
266
        }                                                               \
 
267
                                                                        \
 
268
        ut_a(ut_list_node_313 == NULL);                                 \
 
269
} while (0)
225
270
 
226
271
#endif
227
272