← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/include/dyn0dyn.ic

  • Committer: Brian Aker
  • Date: 2009-01-07 09:27:07 UTC
  • Revision ID: brian@tangent.org-20090107092707-bn67qpdllfcyh3j9
Removing dead field translator code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/dyn0dyn.ic
1
 
/*****************************************************************************
2
 
 
3
 
Copyright (C) 1996, 2009, 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/dyn0dyn.ic
 
1
/******************************************************
21
2
The dynamically allocated array
22
3
 
 
4
(c) 1996 Innobase Oy
 
5
 
23
6
Created 2/5/1996 Heikki Tuuri
24
7
*******************************************************/
25
8
 
26
 
/** Value of dyn_block_struct::magic_n */
27
9
#define DYN_BLOCK_MAGIC_N       375767
28
 
/** Flag for dyn_block_struct::used that indicates a full block */
29
10
#define DYN_BLOCK_FULL_FLAG     0x1000000UL
30
11
 
31
 
/************************************************************//**
32
 
Adds a new block to a dyn array.
33
 
@return created block */
 
12
/****************************************************************
 
13
Adds a new block to a dyn array. */
34
14
UNIV_INTERN
35
15
dyn_block_t*
36
16
dyn_array_add_block(
37
17
/*================*/
38
 
        dyn_array_t*    arr);   /*!< in: dyn array */
39
 
 
40
 
 
41
 
/************************************************************//**
 
18
                                /* out: created block */
 
19
        dyn_array_t*    arr);   /* in: dyn array */
 
20
 
 
21
 
 
22
/****************************************************************
42
23
Gets the first block in a dyn array. */
43
24
UNIV_INLINE
44
25
dyn_block_t*
45
26
dyn_array_get_first_block(
46
27
/*======================*/
47
 
        dyn_array_t*    arr)    /*!< in: dyn array */
 
28
        dyn_array_t*    arr)    /* in: dyn array */
48
29
{
49
30
        return(arr);
50
31
}
51
32
 
52
 
/************************************************************//**
 
33
/****************************************************************
53
34
Gets the last block in a dyn array. */
54
35
UNIV_INLINE
55
36
dyn_block_t*
56
37
dyn_array_get_last_block(
57
38
/*=====================*/
58
 
        dyn_array_t*    arr)    /*!< in: dyn array */
 
39
        dyn_array_t*    arr)    /* in: dyn array */
59
40
{
60
41
        if (arr->heap == NULL) {
61
42
 
65
46
        return(UT_LIST_GET_LAST(arr->base));
66
47
}
67
48
 
68
 
/********************************************************************//**
69
 
Gets the next block in a dyn array.
70
 
@return pointer to next, NULL if end of list */
 
49
/************************************************************************
 
50
Gets the next block in a dyn array. */
71
51
UNIV_INLINE
72
52
dyn_block_t*
73
53
dyn_array_get_next_block(
74
54
/*=====================*/
75
 
        dyn_array_t*    arr,    /*!< in: dyn array */
76
 
        dyn_block_t*    block)  /*!< in: dyn array block */
 
55
                                /* out: pointer to next, NULL if end of list */
 
56
        dyn_array_t*    arr,    /* in: dyn array */
 
57
        dyn_block_t*    block)  /* in: dyn array block */
77
58
{
78
59
        ut_ad(arr && block);
79
60
 
86
67
        return(UT_LIST_GET_NEXT(list, block));
87
68
}
88
69
 
89
 
/********************************************************************//**
90
 
Gets the number of used bytes in a dyn array block.
91
 
@return number of bytes used */
 
70
/************************************************************************
 
71
Gets the number of used bytes in a dyn array block. */
92
72
UNIV_INLINE
93
73
ulint
94
74
dyn_block_get_used(
95
75
/*===============*/
96
 
        dyn_block_t*    block)  /*!< in: dyn array block */
 
76
                                /* out: number of bytes used */
 
77
        dyn_block_t*    block)  /* in: dyn array block */
97
78
{
98
79
        ut_ad(block);
99
80
 
100
81
        return((block->used) & ~DYN_BLOCK_FULL_FLAG);
101
82
}
102
83
 
103
 
/********************************************************************//**
104
 
Gets pointer to the start of data in a dyn array block.
105
 
@return pointer to data */
 
84
/************************************************************************
 
85
Gets pointer to the start of data in a dyn array block. */
106
86
UNIV_INLINE
107
87
byte*
108
88
dyn_block_get_data(
109
89
/*===============*/
110
 
        dyn_block_t*    block)  /*!< in: dyn array block */
 
90
                                /* out: pointer to data */
 
91
        dyn_block_t*    block)  /* in: dyn array block */
111
92
{
112
93
        ut_ad(block);
113
94
 
114
95
        return(block->data);
115
96
}
116
97
 
117
 
/*********************************************************************//**
118
 
Initializes a dynamic array.
119
 
@return initialized dyn array */
 
98
/*************************************************************************
 
99
Initializes a dynamic array. */
120
100
UNIV_INLINE
121
101
dyn_array_t*
122
102
dyn_array_create(
123
103
/*=============*/
124
 
        dyn_array_t*    arr)    /*!< in: pointer to a memory buffer of
 
104
                                /* out: initialized dyn array */
 
105
        dyn_array_t*    arr)    /* in: pointer to a memory buffer of
125
106
                                size sizeof(dyn_array_t) */
126
107
{
127
108
        ut_ad(arr);
139
120
        return(arr);
140
121
}
141
122
 
142
 
/************************************************************//**
 
123
/****************************************************************
143
124
Frees a dynamic array. */
144
125
UNIV_INLINE
145
126
void
146
127
dyn_array_free(
147
128
/*===========*/
148
 
        dyn_array_t*    arr)    /*!< in: dyn array */
 
129
        dyn_array_t*    arr)    /* in: dyn array */
149
130
{
150
131
        if (arr->heap != NULL) {
151
132
                mem_heap_free(arr->heap);
156
137
#endif
157
138
}
158
139
 
159
 
/*********************************************************************//**
 
140
/*************************************************************************
160
141
Makes room on top of a dyn array and returns a pointer to the added element.
161
 
The caller must copy the element to the pointer returned.
162
 
@return pointer to the element */
 
142
The caller must copy the element to the pointer returned. */
163
143
UNIV_INLINE
164
144
void*
165
145
dyn_array_push(
166
146
/*===========*/
167
 
        dyn_array_t*    arr,    /*!< in: dynamic array */
168
 
        ulint           size)   /*!< in: size in bytes of the element */
 
147
                                /* out: pointer to the element */
 
148
        dyn_array_t*    arr,    /* in: dynamic array */
 
149
        ulint           size)   /* in: size in bytes of the element */
169
150
{
170
151
        dyn_block_t*    block;
171
152
        ulint           used;
196
177
        return((block->data) + used);
197
178
}
198
179
 
199
 
/*********************************************************************//**
 
180
/*************************************************************************
200
181
Makes room on top of a dyn array and returns a pointer to a buffer in it.
201
182
After copying the elements, the caller must close the buffer using
202
 
dyn_array_close.
203
 
@return pointer to the buffer */
 
183
dyn_array_close. */
204
184
UNIV_INLINE
205
185
byte*
206
186
dyn_array_open(
207
187
/*===========*/
208
 
        dyn_array_t*    arr,    /*!< in: dynamic array */
209
 
        ulint           size)   /*!< in: size in bytes of the buffer; MUST be
 
188
                                /* out: pointer to the buffer */
 
189
        dyn_array_t*    arr,    /* in: dynamic array */
 
190
        ulint           size)   /* in: size in bytes of the buffer; MUST be
210
191
                                smaller than DYN_ARRAY_DATA_SIZE! */
211
192
{
212
193
        dyn_block_t*    block;
242
223
        return((block->data) + used);
243
224
}
244
225
 
245
 
/*********************************************************************//**
 
226
/*************************************************************************
246
227
Closes the buffer returned by dyn_array_open. */
247
228
UNIV_INLINE
248
229
void
249
230
dyn_array_close(
250
231
/*============*/
251
 
        dyn_array_t*    arr,    /*!< in: dynamic array */
252
 
        byte*           ptr)    /*!< in: buffer space from ptr up was not used */
 
232
        dyn_array_t*    arr,    /* in: dynamic array */
 
233
        byte*           ptr)    /* in: buffer space from ptr up was not used */
253
234
{
254
235
        dyn_block_t*    block;
255
236
 
269
250
#endif
270
251
}
271
252
 
272
 
/************************************************************//**
273
 
Returns pointer to an element in dyn array.
274
 
@return pointer to element */
 
253
/****************************************************************
 
254
Returns pointer to an element in dyn array. */
275
255
UNIV_INLINE
276
256
void*
277
257
dyn_array_get_element(
278
258
/*==================*/
279
 
        dyn_array_t*    arr,    /*!< in: dyn array */
280
 
        ulint           pos)    /*!< in: position of element as bytes
 
259
                                /* out: pointer to element */
 
260
        dyn_array_t*    arr,    /* in: dyn array */
 
261
        ulint           pos)    /* in: position of element as bytes
281
262
                                from array start */
282
263
{
283
264
        dyn_block_t*    block;
307
288
        return(block->data + pos);
308
289
}
309
290
 
310
 
/************************************************************//**
311
 
Returns the size of stored data in a dyn array.
312
 
@return data size in bytes */
 
291
/****************************************************************
 
292
Returns the size of stored data in a dyn array. */
313
293
UNIV_INLINE
314
294
ulint
315
295
dyn_array_get_data_size(
316
296
/*====================*/
317
 
        dyn_array_t*    arr)    /*!< in: dyn array */
 
297
                                /* out: data size in bytes */
 
298
        dyn_array_t*    arr)    /* in: dyn array */
318
299
{
319
300
        dyn_block_t*    block;
320
301
        ulint           sum     = 0;
338
319
        return(sum);
339
320
}
340
321
 
341
 
/********************************************************//**
 
322
/************************************************************
342
323
Pushes n bytes to a dyn array. */
343
324
UNIV_INLINE
344
325
void
345
326
dyn_push_string(
346
327
/*============*/
347
 
        dyn_array_t*    arr,    /*!< in: dyn array */
348
 
        const byte*     str,    /*!< in: string to write */
349
 
        ulint           len)    /*!< in: string length */
 
328
        dyn_array_t*    arr,    /* in: dyn array */
 
329
        const byte*     str,    /* in: string to write */
 
330
        ulint           len)    /* in: string length */
350
331
{
351
332
        ulint   n_copied;
352
333