← Back to branch summary

~ubuntu-branches/ubuntu/precise/mysql-5.1/precise

« back to all changes in this revision

Viewing changes to storage/ndb/include/kernel/signaldata/TcKeyReq.hpp

  • Committer: Bazaar Package Importer
  • Author(s): Norbert Tretkowski
  • Date: 2010-03-17 14:56:02 UTC
  • Revision ID: james.westby@ubuntu.com-20100317145602-x7e30l1b2sb5s6w6
Tags: upstream-5.1.45
Import upstream version 5.1.45

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/ndb/include/kernel/signaldata/TcKeyReq.hpp
 
1
/* Copyright (C) 2003 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
 
16
#ifndef TC_KEY_REQ_H
 
17
#define TC_KEY_REQ_H
 
18
 
 
19
#include "SignalData.hpp"
 
20
 
 
21
/**
 
22
 * @class TcKeyReq
 
23
 * @brief Contains KeyInfo and AttrInfo and is commonly followed by more signals
 
24
 *
 
25
 * - SENDER:    API, NDBCNTR
 
26
 * - RECEIVER:  TC
 
27
 */
 
28
class TcKeyReq {
 
29
  /**
 
30
   * Receiver(s)
 
31
   */
 
32
  friend class Dbtc;         // Receiver
 
33
 
 
34
  /**
 
35
   * Sender(s)
 
36
   */
 
37
  friend class Ndbcntr;      
 
38
  friend class NdbOperation; 
 
39
  friend class NdbIndexOperation;
 
40
  friend class NdbScanOperation;
 
41
  friend class NdbBlob;
 
42
  friend class DbUtil;
 
43
 
 
44
  /**
 
45
   * For printing
 
46
   */
 
47
  friend bool printTCKEYREQ(FILE *, const Uint32 *, Uint32, Uint16);
 
48
  friend bool printTCINDXREQ(FILE *, const Uint32 *, Uint32, Uint16);
 
49
 
 
50
public:
 
51
  /**
 
52
   * Length of signal
 
53
   */
 
54
  STATIC_CONST( StaticLength = 8 );
 
55
  STATIC_CONST( SignalLength = 25 );
 
56
  STATIC_CONST( MaxKeyInfo = 8 );
 
57
  STATIC_CONST( MaxAttrInfo = 5 );
 
58
  STATIC_CONST( MaxTotalAttrInfo = 0xFFFF );
 
59
 
 
60
private:
 
61
 
 
62
  enum AbortOption {
 
63
    CommitIfFailFree = 0, AbortOnError = 0,
 
64
    CommitAsMuchAsPossible = 2, IgnoreError = 2
 
65
  };
 
66
  
 
67
  typedef AbortOption CommitType;
 
68
  
 
69
  /**
 
70
   * DATA VARIABLES
 
71
   */
 
72
 
 
73
  // ----------------------------------------------------------------------
 
74
  //  Unconditional part = must be present in signal.  First 8 words
 
75
  // ----------------------------------------------------------------------
 
76
  Uint32 apiConnectPtr;        // DATA 0
 
77
  union {
 
78
    Uint32 senderData;
 
79
    UintR apiOperationPtr;      // DATA 1
 
80
  };
 
81
  /**
 
82
   * ATTRIBUTE INFO (attrinfo) LENGTH
 
83
   * This is the total length of all attribute info that is sent from
 
84
   * the application as part of this operation. 
 
85
   * It includes all attribute info sent in possible attrinfo 
 
86
   * signals as well as the attribute info sent in TCKEYREQ.
 
87
   */
 
88
  UintR attrLen;              // DATA 2   (also stores API Version)
 
89
  UintR tableId;              // DATA 3
 
90
  UintR requestInfo;          // DATA 4   Various transaction flags
 
91
  UintR tableSchemaVersion;   // DATA 5
 
92
  UintR transId1;             // DATA 6
 
93
  UintR transId2;             // DATA 7
 
94
 
 
95
  // ----------------------------------------------------------------------
 
96
  //  Conditional part = can be present in signal. 
 
97
  //  These four words will be sent only if their indicator is set.
 
98
  // ----------------------------------------------------------------------
 
99
  UintR scanInfo;             // DATA 8   Various flags for scans
 
100
  UintR distrGroupHashValue;  // DATA 9
 
101
  UintR distributionKeySize;  // DATA 10
 
102
  UintR storedProcId;         // DATA 11
 
103
 
 
104
  // ----------------------------------------------------------------------
 
105
  //  Variable sized KEY and ATTRINFO part. 
 
106
  //  These will be placed to pack the signal in an appropriate manner.
 
107
  // ----------------------------------------------------------------------
 
108
  UintR keyInfo[MaxKeyInfo];           // DATA 12 - 19
 
109
  UintR attrInfo[MaxAttrInfo];          // DATA 20 - 24
 
110
  
 
111
  /**
 
112
   * Get:ers for attrLen
 
113
   */ 
 
114
 
 
115
  static Uint16  getAPIVersion(const UintR & attrLen);
 
116
  static Uint16  getAttrinfoLen(const UintR & attrLen);
 
117
  static void setAPIVersion(UintR & attrLen, Uint16 apiVersion);
 
118
  static void setAttrinfoLen(UintR & attrLen, Uint16 aiLen);
 
119
 
 
120
 
 
121
  /**
 
122
   * Get:ers for requestInfo
 
123
   */
 
124
  static Uint8 getCommitFlag(const UintR & requestInfo);
 
125
  static Uint8 getAbortOption(const UintR & requestInfo);
 
126
  static Uint8 getStartFlag(const UintR & requestInfo);
 
127
  static Uint8 getSimpleFlag(const UintR & requestInfo);
 
128
  static Uint8 getDirtyFlag(const UintR & requestInfo);
 
129
  static Uint8 getInterpretedFlag(const UintR & requestInfo);
 
130
  static Uint8 getDistributionKeyFlag(const UintR & requestInfo);
 
131
  static Uint8 getScanIndFlag(const UintR & requestInfo);
 
132
  static Uint8 getOperationType(const UintR & requestInfo);
 
133
  static Uint8 getExecuteFlag(const UintR & requestInfo);
 
134
 
 
135
  static Uint16 getKeyLength(const UintR & requestInfo);
 
136
  static Uint8  getAIInTcKeyReq(const UintR & requestInfo);
 
137
  static Uint8  getExecutingTrigger(const UintR & requestInfo);
 
138
  static UintR  getNoDiskFlag(const UintR & requestInfo);
 
139
 
 
140
  /**
 
141
   * Get:ers for scanInfo
 
142
   */
 
143
  static Uint8  getTakeOverScanFlag(const UintR & scanInfo);
 
144
  static Uint16 getTakeOverScanFragment(const UintR & scanInfo);
 
145
  static Uint32 getTakeOverScanInfo(const UintR & scanInfo);
 
146
 
 
147
 
 
148
  /**
 
149
   * Set:ers for requestInfo
 
150
   */
 
151
  static void clearRequestInfo(UintR & requestInfo);
 
152
  static void setAbortOption(UintR & requestInfo, Uint32 type);
 
153
  static void setCommitFlag(UintR & requestInfo, Uint32 flag);
 
154
  static void setStartFlag(UintR & requestInfo, Uint32 flag);
 
155
  static void setSimpleFlag(UintR & requestInfo, Uint32 flag);
 
156
  static void setDirtyFlag(UintR & requestInfo, Uint32 flag);
 
157
  static void setInterpretedFlag(UintR & requestInfo, Uint32 flag);
 
158
  static void setDistributionKeyFlag(UintR & requestInfo, Uint32 flag);
 
159
  static void setScanIndFlag(UintR & requestInfo, Uint32 flag);
 
160
  static void setExecuteFlag(UintR & requestInfo, Uint32 flag);  
 
161
  static void setOperationType(UintR & requestInfo, Uint32 type);
 
162
  
 
163
  static void setKeyLength(UintR & requestInfo, Uint32 len);
 
164
  static void setAIInTcKeyReq(UintR & requestInfo, Uint32 len);
 
165
  static void setExecutingTrigger(UintR & requestInfo, Uint32 flag);
 
166
  static void setNoDiskFlag(UintR & requestInfo, UintR val);
 
167
 
 
168
  /**
 
169
   * Set:ers for scanInfo
 
170
   */
 
171
  static void setTakeOverScanFlag(UintR & scanInfo, Uint8 flag);
 
172
  static void setTakeOverScanFragment(UintR & scanInfo, Uint16 fragment);
 
173
  static void setTakeOverScanInfo(UintR & scanInfo, Uint32 aScanInfo);
 
174
};
 
175
 
 
176
/**
 
177
 * Request Info
 
178
 *
 
179
 a = Attr Info in TCKEYREQ - 3  Bits -> Max 7 (Bit 16-18)
 
180
 b = Distribution Key Ind  - 1  Bit 2
 
181
 c = Commit Indicator      - 1  Bit 4
 
182
 d = Dirty Indicator       - 1  Bit 0
 
183
 e = Scan Indicator        - 1  Bit 14
 
184
 f = Execute fired trigger - 1  Bit 19 
 
185
 i = Interpreted Indicator - 1  Bit 15
 
186
 k = Key length            - 12 Bits -> Max 4095 (Bit 20 - 31)
 
187
 o = Operation Type        - 3  Bits -> Max 7 (Bit 5-7)
 
188
 l = Execute               - 1  Bit 10
 
189
 p = Simple Indicator      - 1  Bit 8
 
190
 s = Start Indicator       - 1  Bit 11
 
191
 y = Commit Type           - 2  Bit 12-13
 
192
 n = No disk flag          - 1  Bit 1
 
193
 
 
194
           1111111111222222222233
 
195
 01234567890123456789012345678901
 
196
 dnb cooop lsyyeiaaafkkkkkkkkkkkk
 
197
*/
 
198
 
 
199
#define TCKEY_NODISK_SHIFT (1)
 
200
#define COMMIT_SHIFT       (4)
 
201
#define START_SHIFT        (11)
 
202
#define SIMPLE_SHIFT       (8)
 
203
#define DIRTY_SHIFT        (0)
 
204
#define EXECUTE_SHIFT      (10)
 
205
#define INTERPRETED_SHIFT  (15)
 
206
#define DISTR_KEY_SHIFT    (2)
 
207
#define SCAN_SHIFT         (14)
 
208
 
 
209
#define OPERATION_SHIFT   (5)
 
210
#define OPERATION_MASK    (7)
 
211
 
 
212
#define AINFO_SHIFT       (16)
 
213
#define AINFO_MASK        (7)
 
214
 
 
215
#define KEY_LEN_SHIFT     (20)
 
216
#define KEY_LEN_MASK      (4095)
 
217
 
 
218
#define COMMIT_TYPE_SHIFT  (12)
 
219
#define COMMIT_TYPE_MASK   (3)
 
220
 
 
221
#define EXECUTING_TRIGGER_SHIFT (19)
 
222
 
 
223
/**
 
224
 * Scan Info
 
225
 *
 
226
 t = Scan take over indicator -  1 Bit
 
227
 n = Take over node           - 12 Bits -> max 65535
 
228
 p = Scan Info                - 18 Bits -> max 4095
 
229
 
 
230
           1111111111222222222233
 
231
 01234567890123456789012345678901
 
232
 tpppppppppppppppppp nnnnnnnnnnnn
 
233
*/
 
234
 
 
235
#define TAKE_OVER_SHIFT      (0)
 
236
 
 
237
#define TAKE_OVER_FRAG_SHIFT (20)
 
238
#define TAKE_OVER_FRAG_MASK  (4095)
 
239
 
 
240
#define SCAN_INFO_SHIFT      (1)
 
241
#define SCAN_INFO_MASK       (262143)
 
242
 
 
243
/**
 
244
 * Attr Len
 
245
 *
 
246
 n = Attrinfo length(words)   - 16 Bits -> max 65535
 
247
 a = API version no           - 16 Bits -> max 65535
 
248
 
 
249
           1111111111222222222233
 
250
 01234567890123456789012345678901
 
251
 aaaaaaaaaaaaaaaannnnnnnnnnnnnnnn
 
252
*/
 
253
 
 
254
#define API_VER_NO_SHIFT     (16)
 
255
#define API_VER_NO_MASK      (65535)
 
256
 
 
257
#define ATTRLEN_SHIFT        (0)
 
258
#define ATTRLEN_MASK         (65535)
 
259
 
 
260
inline
 
261
Uint8
 
262
TcKeyReq::getCommitFlag(const UintR & requestInfo){
 
263
  return (Uint8)((requestInfo >> COMMIT_SHIFT) & 1);
 
264
}
 
265
 
 
266
inline
 
267
Uint8
 
268
TcKeyReq::getAbortOption(const UintR & requestInfo){
 
269
  return (Uint8)((requestInfo >> COMMIT_TYPE_SHIFT) & COMMIT_TYPE_MASK);
 
270
}
 
271
 
 
272
inline
 
273
Uint8
 
274
TcKeyReq::getStartFlag(const UintR & requestInfo){
 
275
  return (Uint8)((requestInfo >> START_SHIFT) & 1);
 
276
}
 
277
 
 
278
inline
 
279
Uint8
 
280
TcKeyReq::getSimpleFlag(const UintR & requestInfo){
 
281
  return (Uint8)((requestInfo >> SIMPLE_SHIFT) & 1);
 
282
}
 
283
 
 
284
inline
 
285
Uint8
 
286
TcKeyReq::getExecuteFlag(const UintR & requestInfo){
 
287
  return (Uint8)((requestInfo >> EXECUTE_SHIFT) & 1);
 
288
}
 
289
 
 
290
inline
 
291
Uint8
 
292
TcKeyReq::getDirtyFlag(const UintR & requestInfo){
 
293
  return (Uint8)((requestInfo >> DIRTY_SHIFT) & 1);
 
294
}
 
295
 
 
296
inline
 
297
Uint8
 
298
TcKeyReq::getInterpretedFlag(const UintR & requestInfo){
 
299
  return (Uint8)((requestInfo >> INTERPRETED_SHIFT) & 1);
 
300
}
 
301
 
 
302
inline
 
303
Uint8
 
304
TcKeyReq::getDistributionKeyFlag(const UintR & requestInfo){
 
305
  return (Uint8)((requestInfo >> DISTR_KEY_SHIFT) & 1);
 
306
}
 
307
 
 
308
inline
 
309
Uint8
 
310
TcKeyReq::getScanIndFlag(const UintR & requestInfo){
 
311
  return (Uint8)((requestInfo >> SCAN_SHIFT) & 1);
 
312
}
 
313
 
 
314
inline
 
315
Uint8
 
316
TcKeyReq::getOperationType(const UintR & requestInfo){
 
317
  return (Uint8)((requestInfo >> OPERATION_SHIFT) & OPERATION_MASK);
 
318
}
 
319
 
 
320
inline
 
321
Uint16 
 
322
TcKeyReq::getKeyLength(const UintR & requestInfo){
 
323
  return (Uint16)((requestInfo >> KEY_LEN_SHIFT) & KEY_LEN_MASK);
 
324
}
 
325
 
 
326
inline
 
327
Uint8
 
328
TcKeyReq::getAIInTcKeyReq(const UintR & requestInfo){
 
329
  return (Uint8)((requestInfo >> AINFO_SHIFT) & AINFO_MASK);
 
330
}
 
331
 
 
332
inline
 
333
Uint8
 
334
TcKeyReq::getExecutingTrigger(const UintR & requestInfo){
 
335
  return (Uint8)((requestInfo >> EXECUTING_TRIGGER_SHIFT) & 1);
 
336
}
 
337
 
 
338
inline
 
339
void 
 
340
TcKeyReq::clearRequestInfo(UintR & requestInfo){
 
341
  requestInfo = 0;
 
342
}
 
343
 
 
344
inline
 
345
void 
 
346
TcKeyReq::setAbortOption(UintR & requestInfo, Uint32 type){
 
347
  ASSERT_MAX(type, COMMIT_TYPE_MASK, "TcKeyReq::setAbortOption");
 
348
  requestInfo &= ~(COMMIT_TYPE_MASK << COMMIT_TYPE_SHIFT);
 
349
  requestInfo |= (type << COMMIT_TYPE_SHIFT);
 
350
}
 
351
 
 
352
inline
 
353
void 
 
354
TcKeyReq::setCommitFlag(UintR & requestInfo, Uint32 flag){
 
355
  ASSERT_BOOL(flag, "TcKeyReq::setCommitFlag");
 
356
  requestInfo &= ~(1 << COMMIT_SHIFT);
 
357
  requestInfo |= (flag << COMMIT_SHIFT);
 
358
}
 
359
 
 
360
inline
 
361
void 
 
362
TcKeyReq::setStartFlag(UintR & requestInfo, Uint32 flag){
 
363
  ASSERT_BOOL(flag, "TcKeyReq::setStartFlag");
 
364
  requestInfo &= ~(1 << START_SHIFT);
 
365
  requestInfo |= (flag << START_SHIFT);
 
366
}
 
367
 
 
368
inline
 
369
void 
 
370
TcKeyReq::setSimpleFlag(UintR & requestInfo, Uint32 flag){
 
371
  ASSERT_BOOL(flag, "TcKeyReq::setSimpleFlag");
 
372
  requestInfo &= ~(1 << SIMPLE_SHIFT);
 
373
  requestInfo |= (flag << SIMPLE_SHIFT);
 
374
}
 
375
 
 
376
inline
 
377
void 
 
378
TcKeyReq::setDirtyFlag(UintR & requestInfo, Uint32 flag){
 
379
  ASSERT_BOOL(flag, "TcKeyReq::setDirstFlag");
 
380
  requestInfo &= ~(1 << DIRTY_SHIFT);
 
381
  requestInfo |= (flag << DIRTY_SHIFT);
 
382
}
 
383
 
 
384
inline
 
385
void 
 
386
TcKeyReq::setExecuteFlag(UintR & requestInfo, Uint32 flag){
 
387
  ASSERT_BOOL(flag, "TcKeyReq::setExecuteFlag");
 
388
  requestInfo &= ~(1 << EXECUTE_SHIFT);
 
389
  requestInfo |= (flag << EXECUTE_SHIFT);
 
390
}
 
391
 
 
392
inline
 
393
void 
 
394
TcKeyReq::setInterpretedFlag(UintR & requestInfo, Uint32 flag){
 
395
  ASSERT_BOOL(flag, "TcKeyReq::setInterpretedFlag");
 
396
  requestInfo &= ~(1 << INTERPRETED_SHIFT);
 
397
  requestInfo |= (flag << INTERPRETED_SHIFT);
 
398
}
 
399
 
 
400
inline
 
401
void 
 
402
TcKeyReq::setDistributionKeyFlag(UintR & requestInfo, Uint32 flag){
 
403
  ASSERT_BOOL(flag, "TcKeyReq::setDistributionKeyFlag");
 
404
  requestInfo &= ~(1 << DISTR_KEY_SHIFT);
 
405
  requestInfo |= (flag << DISTR_KEY_SHIFT);
 
406
}
 
407
 
 
408
inline
 
409
void 
 
410
TcKeyReq::setScanIndFlag(UintR & requestInfo, Uint32 flag){
 
411
  ASSERT_BOOL(flag, "TcKeyReq::setScanIndFlag");
 
412
  requestInfo &= ~(1 << SCAN_SHIFT);
 
413
  requestInfo |= (flag << SCAN_SHIFT);
 
414
}
 
415
 
 
416
inline
 
417
void 
 
418
TcKeyReq::setOperationType(UintR & requestInfo, Uint32 type){
 
419
  ASSERT_MAX(type, OPERATION_MASK, "TcKeyReq::setOperationType");
 
420
  requestInfo &= ~(OPERATION_MASK << OPERATION_SHIFT);
 
421
  requestInfo |= (type << OPERATION_SHIFT);
 
422
}
 
423
 
 
424
inline
 
425
void 
 
426
TcKeyReq::setKeyLength(UintR & requestInfo, Uint32 len){
 
427
  ASSERT_MAX(len, KEY_LEN_MASK, "TcKeyReq::setKeyLength");
 
428
  requestInfo &= ~(KEY_LEN_MASK << KEY_LEN_SHIFT);
 
429
  requestInfo |= (len << KEY_LEN_SHIFT);
 
430
}
 
431
 
 
432
inline
 
433
void 
 
434
TcKeyReq::setAIInTcKeyReq(UintR & requestInfo, Uint32 len){
 
435
  ASSERT_MAX(len, AINFO_MASK, "TcKeyReq::setAIInTcKeyReq");
 
436
  requestInfo &= ~(AINFO_MASK << AINFO_SHIFT);
 
437
  requestInfo |= (len << AINFO_SHIFT);
 
438
}
 
439
 
 
440
inline
 
441
void 
 
442
TcKeyReq::setExecutingTrigger(UintR & requestInfo, Uint32 flag){
 
443
  ASSERT_BOOL(flag, "TcKeyReq::setExecutingTrigger");
 
444
  requestInfo &= ~(1 << EXECUTING_TRIGGER_SHIFT);
 
445
  requestInfo |= (flag << EXECUTING_TRIGGER_SHIFT);
 
446
}
 
447
 
 
448
inline
 
449
Uint8 
 
450
TcKeyReq::getTakeOverScanFlag(const UintR & scanInfo){
 
451
  return (Uint8)((scanInfo >> TAKE_OVER_SHIFT) & 1);
 
452
}
 
453
 
 
454
inline
 
455
Uint16
 
456
TcKeyReq::getTakeOverScanFragment(const UintR & scanInfo){
 
457
  return (Uint16)((scanInfo >> TAKE_OVER_FRAG_SHIFT) & TAKE_OVER_FRAG_MASK);
 
458
}
 
459
 
 
460
inline
 
461
Uint32 
 
462
TcKeyReq::getTakeOverScanInfo(const UintR & scanInfo){
 
463
  return (Uint32)((scanInfo >> SCAN_INFO_SHIFT) & SCAN_INFO_MASK);
 
464
}
 
465
 
 
466
 
 
467
inline
 
468
void
 
469
TcKeyReq::setTakeOverScanFlag(UintR & scanInfo, Uint8 flag){
 
470
  ASSERT_BOOL(flag, "TcKeyReq::setTakeOverScanFlag");
 
471
  scanInfo |= (flag << TAKE_OVER_SHIFT);
 
472
}
 
473
 
 
474
inline
 
475
void
 
476
TcKeyReq::setTakeOverScanFragment(UintR & scanInfo, Uint16 node){
 
477
//  ASSERT_MAX(node, TAKE_OVER_NODE_MASK, "TcKeyReq::setTakeOverScanNode");
 
478
  scanInfo |= (node << TAKE_OVER_FRAG_SHIFT);
 
479
}
 
480
 
 
481
inline
 
482
void
 
483
TcKeyReq::setTakeOverScanInfo(UintR & scanInfo, Uint32 aScanInfo){
 
484
//  ASSERT_MAX(aScanInfo, SCAN_INFO_MASK, "TcKeyReq::setTakeOverScanInfo");
 
485
  scanInfo |= (aScanInfo << SCAN_INFO_SHIFT);
 
486
}
 
487
 
 
488
 
 
489
inline
 
490
Uint16
 
491
TcKeyReq::getAPIVersion(const UintR & anAttrLen){
 
492
  return (Uint16)((anAttrLen >> API_VER_NO_SHIFT) & API_VER_NO_MASK);
 
493
}
 
494
 
 
495
inline
 
496
void
 
497
TcKeyReq::setAPIVersion(UintR & anAttrLen, Uint16 apiVersion){
 
498
// ASSERT_MAX(apiVersion, API_VER_NO_MASK, "TcKeyReq::setAPIVersion");
 
499
  anAttrLen |= (apiVersion << API_VER_NO_SHIFT);
 
500
}
 
501
 
 
502
inline
 
503
Uint16
 
504
TcKeyReq::getAttrinfoLen(const UintR & anAttrLen){
 
505
  return (Uint16)((anAttrLen) & ATTRLEN_MASK);
 
506
}
 
507
 
 
508
inline
 
509
void
 
510
TcKeyReq::setAttrinfoLen(UintR & anAttrLen, Uint16 aiLen){
 
511
//  ASSERT_MAX(aiLen, ATTRLEN_MASK, "TcKeyReq::setAttrinfoLen");
 
512
  anAttrLen |= aiLen;
 
513
}
 
514
 
 
515
inline
 
516
UintR 
 
517
TcKeyReq::getNoDiskFlag(const UintR & requestInfo){
 
518
  return (requestInfo >> TCKEY_NODISK_SHIFT) & 1;
 
519
}
 
520
 
 
521
inline
 
522
void 
 
523
TcKeyReq::setNoDiskFlag(UintR & requestInfo, Uint32 flag){
 
524
  ASSERT_BOOL(flag, "TcKeyReq::setNoDiskFlag");
 
525
  requestInfo &= ~(1 << TCKEY_NODISK_SHIFT);
 
526
  requestInfo |= (flag << TCKEY_NODISK_SHIFT);
 
527
}
 
528
 
 
529
#endif