← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Brian Aker
  • Date: 2010-04-05 23:46:43 UTC
  • Revision ID: brian@gaz-20100405234643-0he3xnj902rc70r8
Fixing tests to work with PBXT.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/ut0rnd.h
16
16
 
17
17
*****************************************************************************/
18
18
 
19
 
/**********************************************************************
 
19
/******************************************************************//**
 
20
@file include/ut0rnd.h
20
21
Random numbers and hashing
21
22
 
22
23
Created 1/20/1994 Heikki Tuuri
29
30
 
30
31
#include "ut0byte.h"
31
32
 
32
 
/* The 'character code' for end of field or string (used
 
33
/** The 'character code' for end of field or string (used
33
34
in folding records */
34
35
#define UT_END_OF_FIELD         257
35
36
 
36
 
/************************************************************
 
37
/********************************************************//**
37
38
This is used to set the random number seed. */
38
39
UNIV_INLINE
39
40
void
40
41
ut_rnd_set_seed(
41
42
/*============*/
42
 
        ulint    seed);          /* in: seed */
43
 
/************************************************************
44
 
The following function generates a series of 'random' ulint integers. */
 
43
        ulint    seed);          /*!< in: seed */
 
44
/********************************************************//**
 
45
The following function generates a series of 'random' ulint integers.
 
46
@return the next 'random' number */
45
47
UNIV_INLINE
46
48
ulint
47
49
ut_rnd_gen_next_ulint(
48
50
/*==================*/
49
 
                        /* out: the next 'random' number */
50
 
        ulint   rnd);   /* in: the previous random number value */
51
 
/*************************************************************
 
51
        ulint   rnd);   /*!< in: the previous random number value */
 
52
/*********************************************************//**
52
53
The following function generates 'random' ulint integers which
53
54
enumerate the value space (let there be N of them) of ulint integers
54
55
in a pseudo-random fashion. Note that the same integer is repeated
55
 
always after N calls to the generator. */
 
56
always after N calls to the generator.
 
57
@return the 'random' number */
56
58
UNIV_INLINE
57
59
ulint
58
60
ut_rnd_gen_ulint(void);
59
61
/*==================*/
60
 
                        /* out: the 'random' number */
61
 
/************************************************************
62
 
Generates a random integer from a given interval. */
 
62
/********************************************************//**
 
63
Generates a random integer from a given interval.
 
64
@return the 'random' number */
63
65
UNIV_INLINE
64
66
ulint
65
67
ut_rnd_interval(
66
68
/*============*/
67
 
                        /* out: the 'random' number */
68
 
        ulint   low,    /* in: low limit; can generate also this value */
69
 
        ulint   high);  /* in: high limit; can generate also this value */
70
 
/*************************************************************
71
 
Generates a random iboolean value. */
 
69
        ulint   low,    /*!< in: low limit; can generate also this value */
 
70
        ulint   high);  /*!< in: high limit; can generate also this value */
 
71
/*********************************************************//**
 
72
Generates a random iboolean value.
 
73
@return the random value */
72
74
UNIV_INLINE
73
75
ibool
74
76
ut_rnd_gen_ibool(void);
75
77
/*=================*/
76
 
                        /* out: the random value */
77
 
/***********************************************************
 
78
/*******************************************************//**
78
79
The following function generates a hash value for a ulint integer
79
80
to a hash table of size table_size, which should be a prime or some
80
 
random number to work reliably. */
 
81
random number to work reliably.
 
82
@return hash value */
81
83
UNIV_INLINE
82
84
ulint
83
85
ut_hash_ulint(
84
86
/*==========*/
85
 
                                /* out: hash value */
86
 
        ulint    key,           /* in: value to be hashed */
87
 
        ulint    table_size);   /* in: hash table size */
88
 
/*****************************************************************
89
 
Folds a pair of ulints. */
 
87
        ulint    key,           /*!< in: value to be hashed */
 
88
        ulint    table_size);   /*!< in: hash table size */
 
89
/*************************************************************//**
 
90
Folds a pair of ulints.
 
91
@return folded value */
90
92
UNIV_INLINE
91
93
ulint
92
94
ut_fold_ulint_pair(
93
95
/*===============*/
94
 
                        /* out: folded value */
95
 
        ulint   n1,     /* in: ulint */
96
 
        ulint   n2)     /* in: ulint */
97
 
        __attribute__((__const__));
98
 
/*****************************************************************
99
 
Folds a dulint. */
 
96
        ulint   n1,     /*!< in: ulint */
 
97
        ulint   n2)     /*!< in: ulint */
 
98
        __attribute__((const));
 
99
/*************************************************************//**
 
100
Folds a dulint.
 
101
@return folded value */
100
102
UNIV_INLINE
101
103
ulint
102
104
ut_fold_dulint(
103
105
/*===========*/
104
 
                        /* out: folded value */
105
 
        dulint  d)      /* in: dulint */
106
 
        __attribute__((__const__));
107
 
/*****************************************************************
108
 
Folds a character string ending in the null character. */
 
106
        dulint  d)      /*!< in: dulint */
 
107
        __attribute__((const));
 
108
/*************************************************************//**
 
109
Folds a character string ending in the null character.
 
110
@return folded value */
109
111
UNIV_INLINE
110
112
ulint
111
113
ut_fold_string(
112
114
/*===========*/
113
 
                                /* out: folded value */
114
 
        const char*     str)    /* in: null-terminated string */
 
115
        const char*     str)    /*!< in: null-terminated string */
115
116
        __attribute__((pure));
116
 
/*****************************************************************
117
 
Folds a binary string. */
 
117
/*************************************************************//**
 
118
Folds a binary string.
 
119
@return folded value */
118
120
UNIV_INLINE
119
121
ulint
120
122
ut_fold_binary(
121
123
/*===========*/
122
 
                                /* out: folded value */
123
 
        const byte*     str,    /* in: string of bytes */
124
 
        ulint           len)    /* in: length */
 
124
        const byte*     str,    /*!< in: string of bytes */
 
125
        ulint           len)    /*!< in: length */
125
126
        __attribute__((pure));
126
 
/***************************************************************
 
127
/***********************************************************//**
127
128
Looks for a prime number slightly greater than the given argument.
128
 
The prime is chosen so that it is not near any power of 2. */
 
129
The prime is chosen so that it is not near any power of 2.
 
130
@return prime */
129
131
UNIV_INTERN
130
132
ulint
131
133
ut_find_prime(
132
134
/*==========*/
133
 
                        /* out: prime */
134
 
        ulint   n)      /* in: positive number > 100 */
135
 
        __attribute__((__const__));
 
135
        ulint   n)      /*!< in: positive number > 100 */
 
136
        __attribute__((const));
136
137
 
137
138
 
138
139
#ifndef UNIV_NONINL