← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/memory/root.h

  • Committer: Brian Aker
  • Date: 2010-08-17 01:34:55 UTC
  • mto: (1711.1.23 build)
  • mto: This revision was merged to the branch mainline in revision 1714.
  • Revision ID: brian@tangent.org-20100817013455-zx3nm7qilxvpwrgb
Style on structure cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/memory/root.h
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
/**
17
17
 * @file
18
18
 * @brief Memory root declarations
19
19
 */
20
20
 
21
 
 
22
 
 
23
21
#ifndef DRIZZLED_MEMORY_ROOT_H
24
22
#define DRIZZLED_MEMORY_ROOT_H
25
23
 
27
25
 
28
26
#include <drizzled/definitions.h>
29
27
 
30
 
#include "drizzled/visibility.h"
31
 
 
32
28
namespace drizzled
33
29
{
34
30
 
64
60
 
65
61
 
66
62
 
67
 
class DRIZZLED_API Root
 
63
class Root
68
64
{
69
65
public:
70
66
 
71
 
  Root() :
72
 
    free(0),
73
 
    used(0),
74
 
    pre_alloc(0),
75
 
    min_malloc(0),
76
 
    block_size(0),
77
 
    block_num(0),
78
 
    first_block_usage(0),
79
 
    error_handler(0)
80
 
  { }
81
 
 
 
67
  Root() { }
82
68
  Root(size_t block_size_arg)
83
69
  {
84
70
    free= used= pre_alloc= 0;
85
71
    min_malloc= 32;
86
72
    block_size= block_size_arg - memory::ROOT_MIN_BLOCK_SIZE;
 
73
    error_handler= 0;
87
74
    block_num= 4;                       /* We shift this with >>2 */
88
75
    first_block_usage= 0;
89
 
    error_handler= 0;
90
76
  }
91
77
 
92
 
  ~Root();
93
 
 
94
78
  /**
95
79
   * blocks with free memory in it 
96
80
   */
123
107
  void (*error_handler)(void);
124
108
  void reset_root_defaults(size_t block_size, size_t prealloc_size);
125
109
  void *alloc_root(size_t Size);
126
 
  inline void *allocate(size_t Size)
127
 
  {
128
 
    return alloc_root(Size);
129
 
  }
130
110
  void mark_blocks_free();
131
111
  void *memdup_root(const void *str, size_t len);
132
112
  char *strdup_root(const char *str);
133
 
 
134
113
  char *strmake_root(const char *str,size_t len);
135
114
  void init_alloc_root(size_t block_size= ROOT_MIN_BLOCK_SIZE);
136
115
 
137
 
  inline void *duplicate(const void *str, size_t len)
138
 
  {
139
 
    return memdup_root(str, len);
140
 
  }
141
 
 
142
116
  inline bool alloc_root_inited()
143
117
  {
144
118
    return min_malloc != 0;
145
119
  }
146
120
  void free_root(myf MyFLAGS);
147
121
  void *multi_alloc_root(int unused, ...);
 
122
 
148
123
};
149
124
 
150
125
} /* namespace memory */