Cleans up the assert and some other things that Fedora 15 found.
[awesomized/libmemcached] / libmemcached / string.cc
1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
2 *
3 * Libmemcached library
4 *
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 * Copyright (C) 2006-2009 Brian Aker All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
10 * met:
11 *
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 *
15 * * Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following disclaimer
17 * in the documentation and/or other materials provided with the
18 * distribution.
19 *
20 * * The names of its contributors may not be used to endorse or
21 * promote products derived from this software without specific prior
22 * written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 *
36 */
37
38
39 #include <libmemcached/common.h>
40
41 inline static memcached_return_t _string_check(memcached_string_st *string, size_t need)
42 {
43 if (need && need > (size_t)(string->current_size - (size_t)(string->end - string->string)))
44 {
45 size_t current_offset= (size_t) (string->end - string->string);
46 char *new_value;
47 size_t adjust;
48 size_t new_size;
49
50 /* This is the block multiplier. To keep it larger and surive division errors we must round it up */
51 adjust= (need - (size_t)(string->current_size - (size_t)(string->end - string->string))) / MEMCACHED_BLOCK_SIZE;
52 adjust++;
53
54 new_size= sizeof(char) * (size_t)((adjust * MEMCACHED_BLOCK_SIZE) + string->current_size);
55 /* Test for overflow */
56 if (new_size < need)
57 return memcached_set_error(*string->root, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT);
58
59 new_value= static_cast<char *>(libmemcached_realloc(string->root, string->string, new_size));
60
61 if (not new_value)
62 {
63 return memcached_set_error(*string->root, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT);
64 }
65
66 string->string= new_value;
67 string->end= string->string + current_offset;
68
69 string->current_size+= (MEMCACHED_BLOCK_SIZE * adjust);
70 }
71
72 return MEMCACHED_SUCCESS;
73 }
74
75 static inline void _init_string(memcached_string_st *self)
76 {
77 self->current_size= 0;
78 self->end= self->string= NULL;
79 }
80
81 memcached_string_st *memcached_string_create(memcached_st *memc, memcached_string_st *self, size_t initial_size)
82 {
83 WATCHPOINT_ASSERT(memc);
84
85 /* Saving malloc calls :) */
86 if (self)
87 {
88 WATCHPOINT_ASSERT(self->options.is_initialized == false);
89
90 memcached_set_allocated(self, false);
91 }
92 else
93 {
94 self= static_cast<memcached_string_st *>(libmemcached_malloc(memc, sizeof(memcached_string_st)));
95
96 if (self == NULL)
97 {
98 return NULL;
99 }
100
101 memcached_set_allocated(self, true);
102 }
103 self->root= memc;
104
105 _init_string(self);
106
107 if (memcached_failed(_string_check(self, initial_size)))
108 {
109 if (memcached_is_allocated(self))
110 {
111 libmemcached_free(memc, self);
112 }
113
114 return NULL;
115 }
116
117 self->options.is_initialized= true;
118
119 WATCHPOINT_ASSERT(self->string == self->end);
120
121 return self;
122 }
123
124 static memcached_return_t memcached_string_append_null(memcached_string_st *string)
125 {
126 if (memcached_failed(_string_check(string, 1)))
127 {
128 return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
129 }
130
131 *string->end= 0;
132
133 return MEMCACHED_SUCCESS;
134 }
135
136 memcached_return_t memcached_string_append_character(memcached_string_st *string,
137 char character)
138 {
139 if (memcached_failed(_string_check(string, 1)))
140 {
141 return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
142 }
143
144 *string->end= character;
145 string->end++;
146
147 return MEMCACHED_SUCCESS;
148 }
149
150 memcached_return_t memcached_string_append(memcached_string_st *string,
151 const char *value, size_t length)
152 {
153 if (memcached_failed(_string_check(string, length)))
154 {
155 return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
156 }
157
158 WATCHPOINT_ASSERT(length <= string->current_size);
159 WATCHPOINT_ASSERT(string->string);
160 WATCHPOINT_ASSERT(string->end >= string->string);
161
162 memcpy(string->end, value, length);
163 string->end+= length;
164
165 return MEMCACHED_SUCCESS;
166 }
167
168 char *memcached_string_c_copy(memcached_string_st *string)
169 {
170 if (not memcached_string_length(string))
171 return NULL;
172
173 char *c_ptr= static_cast<char *>(libmemcached_malloc(string->root, (memcached_string_length(string)+1) * sizeof(char)));
174
175 if (not c_ptr)
176 return NULL;
177
178 memcpy(c_ptr, memcached_string_value(string), memcached_string_length(string));
179 c_ptr[memcached_string_length(string)]= 0;
180
181 return c_ptr;
182 }
183
184 memcached_return_t memcached_string_reset(memcached_string_st *string)
185 {
186 string->end= string->string;
187
188 return MEMCACHED_SUCCESS;
189 }
190
191 void memcached_string_free(memcached_string_st *ptr)
192 {
193 if (not ptr)
194 return;
195
196 if (ptr->string)
197 {
198 libmemcached_free(ptr->root, ptr->string);
199 }
200
201 if (memcached_is_allocated(ptr))
202 {
203 libmemcached_free(ptr->root, ptr);
204 }
205 else
206 {
207 ptr->options.is_initialized= false;
208 }
209 }
210
211 memcached_return_t memcached_string_check(memcached_string_st *string, size_t need)
212 {
213 return _string_check(string, need);
214 }
215
216 size_t memcached_string_length(const memcached_string_st *self)
217 {
218 return (size_t)(self->end - self->string);
219 }
220
221 size_t memcached_string_size(const memcached_string_st *self)
222 {
223 return self->current_size;
224 }
225
226 const char *memcached_string_value(const memcached_string_st *self)
227 {
228 return self->string;
229 }
230
231 char *memcached_string_take_value(memcached_string_st *self)
232 {
233 assert_msg(self, "Invalid memcached_string_st");
234 // If we fail at adding the null, we copy and move on
235 if (memcached_success(memcached_string_append_null(self)))
236 {
237 return memcached_string_c_copy(self);
238 }
239
240 char *value= self->string;
241
242 _init_string(self);
243
244 return value;
245 }
246
247 char *memcached_string_value_mutable(const memcached_string_st *self)
248 {
249 return self->string;
250 }
251
252 void memcached_string_set_length(memcached_string_st *self, size_t length)
253 {
254 self->end= self->string + length;
255 }