Updating for 1.0.2 release
[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 {
195 return;
196 }
197
198 if (ptr->string)
199 {
200 libmemcached_free(ptr->root, ptr->string);
201 }
202
203 if (memcached_is_allocated(ptr))
204 {
205 libmemcached_free(ptr->root, ptr);
206 }
207 else
208 {
209 ptr->options.is_initialized= false;
210 }
211 }
212
213 memcached_return_t memcached_string_check(memcached_string_st *string, size_t need)
214 {
215 return _string_check(string, need);
216 }
217
218 size_t memcached_string_length(const memcached_string_st *self)
219 {
220 return size_t(self->end -self->string);
221 }
222
223 size_t memcached_string_size(const memcached_string_st *self)
224 {
225 return self->current_size;
226 }
227
228 const char *memcached_string_value(const memcached_string_st *self)
229 {
230 return self->string;
231 }
232
233 char *memcached_string_take_value(memcached_string_st *self)
234 {
235 assert_msg(self, "Invalid memcached_string_st");
236 // If we fail at adding the null, we copy and move on
237 if (memcached_success(memcached_string_append_null(self)))
238 {
239 return memcached_string_c_copy(self);
240 }
241
242 char *value= self->string;
243
244 _init_string(self);
245
246 return value;
247 }
248
249 char *memcached_string_value_mutable(const memcached_string_st *self)
250 {
251 return self->string;
252 }
253
254 void memcached_string_set_length(memcached_string_st *self, size_t length)
255 {
256 self->end= self->string + length;
257 }