jenkins-promote-staging-trunk-libmemcached-7
[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
47 /* This is the block multiplier. To keep it larger and surive division errors we must round it up */
48 size_t adjust= (need - (size_t)(string->current_size - (size_t)(string->end - string->string))) / MEMCACHED_BLOCK_SIZE;
49 adjust++;
50
51 size_t new_size= sizeof(char) * (size_t)((adjust * MEMCACHED_BLOCK_SIZE) + string->current_size);
52 /* Test for overflow */
53 if (new_size < need)
54 {
55 char error_message[1024];
56 int error_message_length= snprintf(error_message, sizeof(error_message),"Needed %ld, got %ld", (long)need, (long)new_size);
57 return memcached_set_error(*string->root, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT, error_message, error_message_length);
58 }
59
60 char *new_value= libmemcached_xrealloc(string->root, string->string, new_size, char);
61
62 if (new_value == NULL)
63 {
64 return memcached_set_error(*string->root, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT);
65 }
66
67 string->string= new_value;
68 string->end= string->string + current_offset;
69
70 string->current_size+= (MEMCACHED_BLOCK_SIZE * adjust);
71 }
72
73 return MEMCACHED_SUCCESS;
74 }
75
76 static inline void _init_string(memcached_string_st *self)
77 {
78 self->current_size= 0;
79 self->end= self->string= NULL;
80 }
81
82 memcached_string_st *memcached_string_create(memcached_st *memc, memcached_string_st *self, size_t initial_size)
83 {
84 WATCHPOINT_ASSERT(memc);
85
86 /* Saving malloc calls :) */
87 if (self)
88 {
89 WATCHPOINT_ASSERT(self->options.is_initialized == false);
90
91 memcached_set_allocated(self, false);
92 }
93 else
94 {
95 self= libmemcached_xmalloc(memc, memcached_string_st);
96
97 if (self == NULL)
98 {
99 return NULL;
100 }
101
102 memcached_set_allocated(self, true);
103 }
104 self->root= memc;
105
106 _init_string(self);
107
108 if (memcached_failed(_string_check(self, initial_size)))
109 {
110 if (memcached_is_allocated(self))
111 {
112 libmemcached_free(memc, self);
113 }
114
115 return NULL;
116 }
117
118 self->options.is_initialized= true;
119
120 WATCHPOINT_ASSERT(self->string == self->end);
121
122 return self;
123 }
124
125 static memcached_return_t memcached_string_append_null(memcached_string_st *string)
126 {
127 if (memcached_failed(_string_check(string, 1)))
128 {
129 return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
130 }
131
132 *string->end= 0;
133
134 return MEMCACHED_SUCCESS;
135 }
136
137 memcached_return_t memcached_string_append_character(memcached_string_st *string,
138 char character)
139 {
140 if (memcached_failed(_string_check(string, 1)))
141 {
142 return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
143 }
144
145 *string->end= character;
146 string->end++;
147
148 return MEMCACHED_SUCCESS;
149 }
150
151 memcached_return_t memcached_string_append(memcached_string_st *string,
152 const char *value, size_t length)
153 {
154 if (memcached_failed(_string_check(string, length)))
155 {
156 return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
157 }
158
159 WATCHPOINT_ASSERT(length <= string->current_size);
160 WATCHPOINT_ASSERT(string->string);
161 WATCHPOINT_ASSERT(string->end >= string->string);
162
163 memcpy(string->end, value, length);
164 string->end+= length;
165
166 return MEMCACHED_SUCCESS;
167 }
168
169 char *memcached_string_c_copy(memcached_string_st *string)
170 {
171 if (not memcached_string_length(string))
172 return NULL;
173
174 char *c_ptr= static_cast<char *>(libmemcached_malloc(string->root, (memcached_string_length(string)+1) * sizeof(char)));
175
176 if (not c_ptr)
177 return NULL;
178
179 memcpy(c_ptr, memcached_string_value(string), memcached_string_length(string));
180 c_ptr[memcached_string_length(string)]= 0;
181
182 return c_ptr;
183 }
184
185 memcached_return_t memcached_string_reset(memcached_string_st *string)
186 {
187 string->end= string->string;
188
189 return MEMCACHED_SUCCESS;
190 }
191
192 void memcached_string_free(memcached_string_st *ptr)
193 {
194 if (not ptr)
195 {
196 return;
197 }
198
199 if (ptr->string)
200 {
201 libmemcached_free(ptr->root, ptr->string);
202 }
203
204 if (memcached_is_allocated(ptr))
205 {
206 libmemcached_free(ptr->root, ptr);
207 }
208 else
209 {
210 ptr->options.is_initialized= false;
211 }
212 }
213
214 memcached_return_t memcached_string_check(memcached_string_st *string, size_t need)
215 {
216 return _string_check(string, need);
217 }
218
219 size_t memcached_string_length(const memcached_string_st *self)
220 {
221 return size_t(self->end -self->string);
222 }
223
224 size_t memcached_string_size(const memcached_string_st *self)
225 {
226 return self->current_size;
227 }
228
229 const char *memcached_string_value(const memcached_string_st *self)
230 {
231 return self->string;
232 }
233
234 char *memcached_string_take_value(memcached_string_st *self)
235 {
236 assert_msg(self, "Invalid memcached_string_st");
237 // If we fail at adding the null, we copy and move on
238 if (memcached_success(memcached_string_append_null(self)))
239 {
240 return memcached_string_c_copy(self);
241 }
242
243 char *value= self->string;
244
245 _init_string(self);
246
247 return value;
248 }
249
250 char *memcached_string_value_mutable(const memcached_string_st *self)
251 {
252 return self->string;
253 }
254
255 void memcached_string_set_length(memcached_string_st *self, size_t length)
256 {
257 self->end= self->string + length;
258 }