← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/pbms/src/cslib/CSDefs.h

This patch completes the first step in the splitting of
the XA resource manager API from the storage engine API,
as outlined in the specification here:

http://drizzle.org/wiki/XaStorageEngine

* Splits plugin::StorageEngine into a base StorageEngine
  class and two derived classes, TransactionalStorageEngine
  and XaStorageEngine.  XaStorageEngine derives from
  TransactionalStorageEngine and creates the XA Resource
  Manager API for storage engines.

  - The methods moved from StorageEngine to TransactionalStorageEngine
    include releaseTemporaryLatches(), startConsistentSnapshot(), 
    commit(), rollback(), setSavepoint(), releaseSavepoint(),
    rollbackToSavepoint() and hasTwoPhaseCommit()
  - The methods moved from StorageEngine to XaStorageEngine
    include recover(), commitXid(), rollbackXid(), and prepare()

* Places all static "EngineVector"s into their proper
  namespaces (typedefs belong in header files, not implementation files)
  and places all static methods corresponding
  to either only transactional engines or only XA engines
  into their respective files in /drizzled/plugin/

* Modifies the InnoDB "handler" files to extend plugin::XaStorageEngine
  and not plugin::StorageEngine

The next step, as outlined in the wiki spec page above, is to isolate
the XA Resource Manager API into its own plugin class and modify
plugin::XaStorageEngine to implement plugin::XaResourceManager via
composition.  This is necessary to enable building plugins which can
participate in an XA transaction *without having to have that plugin
implement the entire storage engine API*

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/pbms/src/cslib/CSDefs.h
1
 
/* Copyright (C) 2008 PrimeBase Technologies GmbH, Germany
2
 
 *
3
 
 * PrimeBase Media Stream for MySQL
4
 
 *
5
 
 * This program is free software; you can redistribute it and/or modify
6
 
 * it under the terms of the GNU General Public License as published by
7
 
 * the Free Software Foundation; either version 2 of the License, or
8
 
 * (at your option) any later version.
9
 
 *
10
 
 * This program is distributed in the hope that it will be useful,
11
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 * GNU General Public License for more details.
14
 
 *
15
 
 * You should have received a copy of the GNU General Public License
16
 
 * along with this program; if not, write to the Free Software
17
 
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18
 
 *
19
 
 * Original author: Paul McCullagh (H&G2JCtL)
20
 
 * Continued development: Barry Leslie
21
 
 *
22
 
 * 2007-06-02
23
 
 *
24
 
 * CORE SYSTEM:
25
 
 * Common definitions that may be required be included at the
26
 
 * top of every header file.
27
 
 *
28
 
 */
29
 
 
30
 
#ifndef __CSDEFS_H__
31
 
#define __CSDEFS_H__
32
 
 
33
 
#include <sys/types.h>
34
 
 
35
 
// Use standard portable data types
36
 
#include <stdint.h>
37
 
 
38
 
/* Those compilers that support the function
39
 
 * macro (in particular the "pretty" function
40
 
 * macro must be defined here.
41
 
 */
42
 
#ifdef OS_WINDOWS
43
 
#define __FUNC__                                __FUNCTION__
44
 
#elif defined(OS_SOLARIS)
45
 
#define __FUNC__                                "__func__"
46
 
#else
47
 
#define __FUNC__                                __PRETTY_FUNCTION__
48
 
#endif
49
 
 
50
 
/*
51
 
 * An unsigned integer, 1 byte long:
52
 
 */
53
 
#ifndef u_char
54
 
#define u_char                  unsigned char
55
 
#endif
56
 
 
57
 
/*
58
 
 * An usigned integer, 1 byte long:
59
 
 */
60
 
#define s_char                  unsigned char
61
 
 
62
 
/* We assumes that off_t is 8 bytes so to ensure this always use  off64_t*/
63
 
#define off64_t                 uint64_t
64
 
 
65
 
 
66
 
/*
67
 
 * A signed integer at least 32 bits long.
68
 
 * The size used is whatever is most
69
 
 * convenient to the machine.
70
 
 */
71
 
#define s_int int_fast32_t
72
 
 
73
 
/* Forward declartion of a thread: */
74
 
class CSThread;
75
 
 
76
 
// Used to avoid warnings about unused parameters.
77
 
#define UNUSED(x) (void)x
78
 
 
79
 
#ifdef OS_WINDOWS
80
 
 
81
 
#define CS_DEFAULT_EOL          "\r\n"
82
 
#define CS_DIR_CHAR                     '\\'
83
 
#define CS_DIR_DELIM            "\\"
84
 
#define IS_DIR_CHAR(ch)         ((ch) == CS_DIR_CHAR || (ch) == '/')
85
 
 
86
 
#ifndef PATH_MAX
87
 
#define PATH_MAX                MAX_PATH
88
 
#endif
89
 
 
90
 
#ifndef NAME_MAX
91
 
#define NAME_MAX                MAX_PATH
92
 
#endif
93
 
 
94
 
#else
95
 
 
96
 
#define CS_DEFAULT_EOL          "\n"
97
 
#define CS_DIR_CHAR                     '/'
98
 
#define CS_DIR_DELIM            "/"
99
 
#define IS_DIR_CHAR(ch)         ((ch) == CS_DIR_CHAR)
100
 
 
101
 
#endif // OS_WINDOWS
102
 
 
103
 
#define CS_CALL_STACK_SIZE              100
104
 
#define CS_RELEASE_STACK_SIZE   200
105
 
#define CS_JUMP_STACK_SIZE              20
106
 
 
107
 
/* C string display width sizes including space for a null terminator and possible sign. */
108
 
#define CS_WIDTH_INT_8  5
109
 
#define CS_WIDTH_INT_16 7
110
 
#define CS_WIDTH_INT_32 12
111
 
#define CS_WIDTH_INT_64 22
112
 
 
113
 
typedef uint8_t                 CSDiskValue1[1];        
114
 
typedef uint8_t                 CSDiskValue2[2];        
115
 
typedef uint8_t                 CSDiskValue3[3];        
116
 
typedef uint8_t                 CSDiskValue4[4];        
117
 
typedef uint8_t                 CSDiskValue6[6];        
118
 
typedef uint8_t                 CSDiskValue8[8];        
119
 
 
120
 
/*
121
 
 * Byte order on the disk is little endian! This is the byte order of the i386.
122
 
 * Little endian byte order starts with the least significan byte.
123
 
 *
124
 
 * The reason for choosing this byte order for the disk is 2-fold:
125
 
 * Firstly the i386 is the cheapest and fasted platform today.
126
 
 * Secondly the i386, unlike RISK chips (with big endian) can address
127
 
 * memory that is not aligned!
128
 
 *
129
 
 * Since the disk image of PrimeBase XT is not aligned, the second point
130
 
 * is significant. A RISK chip needs to access it byte-wise, so we might as
131
 
 * well do the byte swapping at the same time.
132
 
 *
133
 
 * The macros below are of 4 general types:
134
 
 *
135
 
 * GET/SET - Get and set 1,2,4,8 byte values (short, int, long, etc).
136
 
 * Values are swapped only on big endian platforms. This makes these
137
 
 * functions very efficient on little-endian platforms.
138
 
 *
139
 
 * COPY - Transfer data without swapping regardless of platform. This
140
 
 * function is a bit more efficient on little-endian platforms
141
 
 * because alignment is not an issue.
142
 
 *
143
 
 * MOVE - Similar to get and set, but the deals with memory instead
144
 
 * of values. Since no swapping is done on little-endian platforms
145
 
 * this function is identical to COPY on little-endian platforms.
146
 
 *
147
 
 * SWAP - Transfer and swap data regardless of the platform type.
148
 
 * Aligment is not assumed.
149
 
 *
150
 
 * The DISK component of the macro names indicates that alignment of
151
 
 * the value cannot be assumed.
152
 
 *
153
 
 */
154
 
#if BYTE_ORDER == BIG_ENDIAN
155
 
/* The native order of the machine is big endian. Since the native disk
156
 
 * disk order of XT is little endian, all data to and from disk
157
 
 * must be swapped.
158
 
 */
159
 
#define CS_SET_DISK_1(d, s)             ((d)[0] = (uint8_t) (s))
160
 
 
161
 
#define CS_SET_DISK_2(d, s)             do { (d)[0] = (uint8_t)  (((uint16_t) (s))        & 0xFF); (d)[1] = (uint8_t) ((((uint16_t) (s)) >> 8 ) & 0xFF); } while (0)
162
 
 
163
 
#define CS_SET_DISK_3(d, s)             do { (d)[0] = (uint8_t)  (((uint32_t) (s))        & 0xFF); (d)[1] = (uint8_t) ((((uint32_t) (s)) >> 8 ) & 0xFF); \
164
 
                                                                         (d)[2] = (uint8_t) ((((uint32_t) (s)) >> 16) & 0xFF); } while (0)
165
 
 
166
 
#define CS_SET_DISK_4(d, s)             do { (d)[0] = (uint8_t)  (((uint32_t) (s))        & 0xFF); (d)[1] = (uint8_t) ((((uint32_t) (s)) >> 8 ) & 0xFF); \
167
 
                                                                         (d)[2] = (uint8_t) ((((uint32_t) (s)) >> 16) & 0xFF); (d)[3] = (uint8_t) ((((uint32_t) (s)) >> 24) & 0xFF); } while (0)
168
 
 
169
 
#define CS_SET_DISK_6(d, s)             do { (d)[0] = (uint8_t)  (((uint64_t) (s))        & 0xFF); (d)[1] = (uint8_t) ((((uint64_t) (s)) >> 8 ) & 0xFF); \
170
 
                                                                         (d)[2] = (uint8_t) ((((uint64_t) (s)) >> 16) & 0xFF); (d)[3] = (uint8_t) ((((uint64_t) (s)) >> 24) & 0xFF); \
171
 
                                                                         (d)[4] = (uint8_t) ((((uint64_t) (s)) >> 32) & 0xFF); (d)[5] = (uint8_t) ((((uint64_t) (s)) >> 40) & 0xFF); } while (0)
172
 
 
173
 
#define CS_SET_DISK_8(d, s)             do { (d)[0] = (uint8_t)  (((uint64_t) (s))        & 0xFF); (d)[1] = (uint8_t) ((((uint64_t) (s)) >> 8 ) & 0xFF); \
174
 
                                                                         (d)[2] = (uint8_t) ((((uint64_t) (s)) >> 16) & 0xFF); (d)[3] = (uint8_t) ((((uint64_t) (s)) >> 24) & 0xFF); \
175
 
                                                                         (d)[4] = (uint8_t) ((((uint64_t) (s)) >> 32) & 0xFF); (d)[5] = (uint8_t) ((((uint64_t) (s)) >> 40) & 0xFF); \
176
 
                                                                         (d)[6] = (uint8_t) ((((uint64_t) (s)) >> 48) & 0xFF); (d)[7] = (uint8_t) ((((uint64_t) (s)) >> 56) & 0xFF); } while (0)
177
 
 
178
 
#define CS_GET_DISK_1(s)                ((s)[0])
179
 
 
180
 
#define CS_GET_DISK_2(s)                ((uint16_t) (((uint16_t) (s)[0]) | (((uint16_t) (s)[1]) << 8)))
181
 
 
182
 
#define CS_GET_DISK_3(s)                ((uint32_t) (((uint32_t) (s)[0]) | (((uint32_t) (s)[1]) << 8) | (((uint32_t) (s)[2]) << 16)))
183
 
 
184
 
#define CS_GET_DISK_4(s)                (((uint32_t) (s)[0])        | (((uint32_t) (s)[1]) << 8 ) | \
185
 
                                                                (((uint32_t) (s)[2]) << 16) | (((uint32_t) (s)[3]) << 24))
186
 
 
187
 
#define CS_GET_DISK_6(s)                (((uint64_t) (s)[0])        | (((uint64_t) (s)[1]) << 8 ) | \
188
 
                                                                (((uint64_t) (s)[2]) << 16) | (((uint64_t) (s)[3]) << 24) | \
189
 
                                                                (((uint64_t) (s)[4]) << 32) | (((uint64_t) (s)[5]) << 40))
190
 
 
191
 
#define CS_GET_DISK_8(s)                (((uint64_t) (s)[0])        | (((uint64_t) (s)[1]) << 8 ) | \
192
 
                                                                (((uint64_t) (s)[2]) << 16) | (((uint64_t) (s)[3]) << 24) | \
193
 
                                                                (((uint64_t) (s)[4]) << 32) | (((uint64_t) (s)[5]) << 40) | \
194
 
                                                                (((uint64_t) (s)[6]) << 48) | (((uint64_t) (s)[7]) << 56))
195
 
 
196
 
/* Move will copy memory, and swap the bytes on a big endian machine.
197
 
 * On a little endian machine it is the same as COPY.
198
 
 */
199
 
#define CS_MOVE_DISK_1(d, s)    ((d)[0] = (s)[0])
200
 
#define CS_MOVE_DISK_2(d, s)    do { (d)[0] = (s)[1]; (d)[1] = (s)[0]; } while (0)
201
 
#define CS_MOVE_DISK_3(d, s)    do { (d)[0] = (s)[2]; (d)[1] = (s)[1]; (d)[2] = (s)[0]; } while (0)
202
 
#define CS_MOVE_DISK_4(d, s)    do { (d)[0] = (s)[3]; (d)[1] = (s)[2]; (d)[2] = (s)[1]; (d)[3] = (s)[0]; } while (0)
203
 
#define CS_MOVE_DISK_8(d, s)    do { (d)[0] = (s)[7]; (d)[1] = (s)[6]; \
204
 
                                                                         (d)[2] = (s)[5]; (d)[3] = (s)[4]; \
205
 
                                                                         (d)[4] = (s)[3]; (d)[5] = (s)[2]; \
206
 
                                                                         (d)[6] = (s)[1]; (d)[7] = (s)[0]; } while (0)
207
 
 
208
 
/*
209
 
 * Copy just copies the number of bytes assuming the data is not alligned.
210
 
 */
211
 
#define CS_COPY_DISK_1(d, s)    (d)[0] = s
212
 
#define CS_COPY_DISK_2(d, s)    do { (d)[0] = (s)[0]; (d)[1] = (s)[1]; } while (0)
213
 
#define CS_COPY_DISK_3(d, s)    do { (d)[0] = (s)[0]; (d)[1] = (s)[1]; (d)[2] = (s)[2]; } while (0)
214
 
#define CS_COPY_DISK_4(d, s)    do { (d)[0] = (s)[0]; (d)[1] = (s)[1]; (d)[2] = (s)[2]; (d)[3] = (s)[3]; } while (0)
215
 
#define CS_COPY_DISK_6(d, s)    memcpy(&((d)[0]), &((s)[0]), 6)
216
 
#define CS_COPY_DISK_8(d, s)    memcpy(&((d)[0]), &((s)[0]), 8)
217
 
#define CS_COPY_DISK_10(d, s)   memcpy(&((d)[0]), &((s)[0]), 10)
218
 
 
219
 
#define CS_SET_NULL_DISK_1(d)   CS_SET_DISK_1(d, 0)
220
 
#define CS_SET_NULL_DISK_2(d)   do { (d)[0] = 0; (d)[1] = 0; } while (0)
221
 
#define CS_SET_NULL_DISK_4(d)   do { (d)[0] = 0; (d)[1] = 0; (d)[2] = 0; (d)[3] = 0; } while (0)
222
 
#define CS_SET_NULL_DISK_6(d)   do { (d)[0] = 0; (d)[1] = 0; (d)[2] = 0; (d)[3] = 0; (d)[4] = 0; (d)[5] = 0; } while (0)
223
 
#define CS_SET_NULL_DISK_8(d)   do { (d)[0] = 0; (d)[1] = 0; (d)[2] = 0; (d)[3] = 0; (d)[4] = 0; (d)[5] = 0; (d)[6] = 0; (d)[7] = 0; } while (0)
224
 
 
225
 
#define CS_IS_NULL_DISK_1(d)    (!(CS_GET_DISK_1(d)))
226
 
#define CS_IS_NULL_DISK_4(d)    (!(d)[0] && !(d)[1] && !(d)[2] && !(d)[3])
227
 
#define CS_IS_NULL_DISK_8(d)    (!(d)[0] && !(d)[1] && !(d)[2] && !(d)[3] && !(d)[4] && !(d)[5] && !(d)[6] && !(7)[3])
228
 
 
229
 
#define CS_EQ_DISK_4(d, s)              ((d)[0] == (s)[0] && (d)[1] == (s)[1] && (d)[2] == (s)[2] && (d)[3] == (s)[3])
230
 
#define CS_EQ_DISK_8(d, s)              ((d)[0] == (s)[0] && (d)[1] == (s)[1] && (d)[2] == (s)[2] && (d)[3] == (s)[3] && \
231
 
                                                                (d)[4] == (s)[4] && (d)[5] == (s)[5] && (d)[6] == (s)[6] && (d)[7] == (s)[7])
232
 
 
233
 
#define CS_IS_FF_DISK_4(d)              ((d)[0] == 0xFF && (d)[1] == 0xFF && (d)[2] == 0xFF && (d)[3] == 0xFF)
234
 
#else
235
 
/*
236
 
 * The native order of the machine is little endian. This means the data to
237
 
 * and from disk need not be swapped. In addition to this, since
238
 
 * the i386 can access non-aligned memory we are not required to
239
 
 * handle the data byte-for-byte.
240
 
 */
241
 
#define CS_SET_DISK_1(d, s)             ((d)[0] = (uint8_t) (s))
242
 
#define CS_SET_DISK_2(d, s)             (*((uint16_t *) &((d)[0])) = (uint16_t) (s))
243
 
#define CS_SET_DISK_3(d, s)             do { (*((uint16_t *) &((d)[0])) = (uint16_t) (s));  *((uint8_t *) &((d)[2])) = (uint8_t) (((uint32_t) (s)) >> 16); } while (0)
244
 
#define CS_SET_DISK_4(d, s)             (*((uint32_t *) &((d)[0])) = (uint32_t) (s))
245
 
#define CS_SET_DISK_6(d, s)             do { *((uint32_t *) &((d)[0])) = (uint32_t) (s); *((uint16_t *) &((d)[4])) = (uint16_t) (((uint64_t) (s)) >> 32); } while (0)
246
 
#define CS_SET_DISK_8(d, s)             (*((uint64_t *) &((d)[0])) = (uint64_t) (s))
247
 
 
248
 
#define CS_GET_DISK_1(s)                ((s)[0])
249
 
#define CS_GET_DISK_2(s)                *((uint16_t *) &((s)[0]))
250
 
#define CS_GET_DISK_3(s)                ((uint32_t) *((uint16_t *) &((s)[0])) | (((uint32_t) *((uint8_t *) &((s)[2]))) << 16))
251
 
#define CS_GET_DISK_4(s)                *((uint32_t *) &((s)[0]))
252
 
#define CS_GET_DISK_6(s)                ((uint64_t) *((uint32_t *) &((s)[0])) | (((uint64_t) *((uint16_t *) &((s)[4]))) << 32))
253
 
#define CS_GET_DISK_8(s)                *((uint64_t *) &((s)[0]))
254
 
 
255
 
#define CS_MOVE_DISK_1(d, s)    ((d)[0] = (s)[0])
256
 
#define CS_MOVE_DISK_2(d, s)    CS_COPY_DISK_2(d, s)
257
 
#define CS_MOVE_DISK_3(d, s)    CS_COPY_DISK_3(d, s)
258
 
#define CS_MOVE_DISK_4(d, s)    CS_COPY_DISK_4(d, s)
259
 
#define CS_MOVE_DISK_8(d, s)    CS_COPY_DISK_8(d, s)
260
 
 
261
 
#define CS_COPY_DISK_1(d, s)    (d)[0] = s
262
 
#define CS_COPY_DISK_2(d, s)    (*((uint16_t *) &((d)[0])) = (*((uint16_t *) &((s)[0]))))
263
 
#define CS_COPY_DISK_3(d, s)    do { *((uint16_t *) &((d)[0])) = *((uint16_t *) &((s)[0])); (d)[2] = (s)[2]; } while (0)
264
 
#define CS_COPY_DISK_4(d, s)    (*((uint32_t *) &((d)[0])) = (*((uint32_t *) &((s)[0]))))
265
 
#define CS_COPY_DISK_6(d, s)    do { *((uint32_t *) &((d)[0])) = *((uint32_t *) &((s)[0])); *((uint16_t *) &((d)[4])) = *((uint16_t *) &((s)[4])); } while (0)
266
 
#define CS_COPY_DISK_8(d, s)    (*((uint64_t *) &(d[0])) = (*((uint64_t *) &((s)[0]))))
267
 
#define CS_COPY_DISK_10(d, s)   memcpy(&((d)[0]), &((s)[0]), 10)
268
 
 
269
 
#define CS_SET_NULL_DISK_1(d)   CS_SET_DISK_1(d, 0)
270
 
#define CS_SET_NULL_DISK_2(d)   CS_SET_DISK_2(d, 0)
271
 
#define CS_SET_NULL_DISK_3(d)   CS_SET_DISK_3(d, 0)
272
 
#define CS_SET_NULL_DISK_4(d)   CS_SET_DISK_4(d, 0L)
273
 
#define CS_SET_NULL_DISK_6(d)   CS_SET_DISK_6(d, 0LL)
274
 
#define CS_SET_NULL_DISK_8(d)   CS_SET_DISK_8(d, 0LL)
275
 
 
276
 
#define CS_IS_NULL_DISK_1(d)    (!(CS_GET_DISK_1(d)))
277
 
#define CS_IS_NULL_DISK_2(d)    (!(CS_GET_DISK_2(d)))
278
 
#define CS_IS_NULL_DISK_3(d)    (!(CS_GET_DISK_3(d)))
279
 
#define CS_IS_NULL_DISK_4(d)    (!(CS_GET_DISK_4(d)))
280
 
#define CS_IS_NULL_DISK_8(d)    (!(CS_GET_DISK_8(d)))
281
 
 
282
 
#define CS_EQ_DISK_4(d, s)              (CS_GET_DISK_4(d) == CS_GET_DISK_4(s))
283
 
#define CS_EQ_DISK_8(d, s)              (CS_GET_DISK_8(d) == CS_GET_DISK_8(s))
284
 
 
285
 
#define CS_IS_FF_DISK_4(d)              (CS_GET_DISK_4(d) == 0xFFFFFFFF)
286
 
#endif
287
 
 
288
 
#define CS_CMP_DISK_4(a, b)             ((int32_t) CS_GET_DISK_4(a) - (int32_t) CS_GET_DISK_4(b))
289
 
#define CS_CMP_DISK_8(d, s)             memcmp(&((d)[0]), &((s)[0]), 8)
290
 
//#define CS_CMP_DISK_8(d, s)           (CS_CMP_DISK_4((d).h_number_4, (s).h_number_4) == 0 ? CS_CMP_DISK_4((d).h_file_4, (s).h_file_4) : CS_CMP_DISK_4((d).h_number_4, (s).h_number_4))
291
 
 
292
 
#define CS_SWAP_DISK_2(d, s)    do { (d)[0] = (s)[1]; (d)[1] = (s)[0]; } while (0)
293
 
#define CS_SWAP_DISK_3(d, s)    do { (d)[0] = (s)[2]; (d)[1] = (s)[1]; (d)[2] = (s)[0]; } while (0)
294
 
#define CS_SWAP_DISK_4(d, s)    do { (d)[0] = (s)[3]; (d)[1] = (s)[2]; (d)[2] = (s)[1]; (d)[3] = (s)[0]; } while (0)
295
 
#define CS_SWAP_DISK_8(d, s)    do { (d)[0] = (s)[7]; (d)[1] = (s)[6]; (d)[2] = (s)[5]; (d)[3] = (s)[4]; \
296
 
                                                                         (d)[4] = (s)[3]; (d)[5] = (s)[2]; (d)[6] = (s)[1]; (d)[7] = (s)[0]; } while (0)
297
 
 
298
 
typedef union {
299
 
        CSDiskValue1 val_1;
300
 
        CSDiskValue4 val_4;
301
 
} CSIntRec, *CSIntPtr;
302
 
 
303
 
typedef union {
304
 
                const char *rec_cchars;
305
 
                char *rec_chars;
306
 
                CSIntPtr int_val;
307
 
} CSDiskData;
308
 
 
309
 
#define CHECKSUM_VALUE_SIZE                     16
310
 
typedef struct {
311
 
        u_char val[CHECKSUM_VALUE_SIZE];
312
 
} Md5Digest;
313
 
 
314
 
        
315
 
#endif