X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fallocators.cc;h=f1caf71ec373eab433bd3832d5d010a3218f2b45;hb=61b948a92ab79734b009a438b5cf3bfad03cb59d;hp=e716bee30ce56cf858aed15b9511bd5b9f463fbd;hpb=67456d74f5bd4f354a360d70da503dc58cbe5971;p=awesomized%2Flibmemcached

diff --git a/libmemcached/allocators.cc b/libmemcached/allocators.cc
index e716bee3..f1caf71e 100644
--- a/libmemcached/allocators.cc
+++ b/libmemcached/allocators.cc
@@ -1,38 +1,74 @@
-#include "common.h"
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  Libmemcached library
+ *
+ *  Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ *  Copyright (C) 2006-2009 Brian Aker All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are
+ *  met:
+ *
+ *      * Redistributions of source code must retain the above copyright
+ *  notice, this list of conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above
+ *  copyright notice, this list of conditions and the following disclaimer
+ *  in the documentation and/or other materials provided with the
+ *  distribution.
+ *
+ *      * The names of its contributors may not be used to endorse or
+ *  promote products derived from this software without specific prior
+ *  written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
 
-void _libmemcached_free(const memcached_st *ptr, void *mem, void *context)
+#include <libmemcached/common.h>
+
+void _libmemcached_free(const memcached_st*, void *mem, void*)
 {
-  (void) ptr;
-  (void) context;
-  free(mem);
+  if (mem)
+  {
+    std::free(mem);
+  }
 }
 
-void *_libmemcached_malloc(const memcached_st *ptr, size_t size, void *context)
+void *_libmemcached_malloc(const memcached_st *, size_t size, void *)
 {
-  (void) ptr;
-  (void) context;
-  return malloc(size);
+  return std::malloc(size);
 }
 
-void *_libmemcached_realloc(const memcached_st *ptr, void *mem, size_t size, void *context)
+void *_libmemcached_realloc(const memcached_st*, void *mem, size_t size, void *)
 {
-  (void) ptr;
-  (void) context;
-  return realloc(mem, size);
+  return std::realloc(mem, size);
 }
 
-void *_libmemcached_calloc(const memcached_st *ptr, size_t nelem, size_t size, void *context)
+void *_libmemcached_calloc(const memcached_st *self, size_t nelem, size_t size, void *context)
 {
-  if (ptr->allocators.malloc != _libmemcached_malloc)
+  if (self->allocators.malloc != _libmemcached_malloc)
   {
-     void *ret = _libmemcached_malloc(ptr, nelem * size, context);
-     if (ret != NULL) 
+     void *ret= _libmemcached_malloc(self, nelem * size, context);
+     if (ret)
+     {
        memset(ret, 0, nelem * size);
+     }
 
      return ret;
   }
 
-  return calloc(nelem, size);
+  return std::calloc(nelem, size);
 }
 
 struct memcached_allocator_t memcached_allocators_return_default(void)
@@ -41,47 +77,78 @@ struct memcached_allocator_t memcached_allocators_return_default(void)
   return global_default_allocator;
 }
 
-memcached_return_t memcached_set_memory_allocators(memcached_st *ptr,
+memcached_return_t memcached_set_memory_allocators(memcached_st *shell,
                                                    memcached_malloc_fn mem_malloc,
                                                    memcached_free_fn mem_free,
                                                    memcached_realloc_fn mem_realloc,
                                                    memcached_calloc_fn mem_calloc,
                                                    void *context)
 {
+  Memcached* self= memcached2Memcached(shell);
+  if (self == NULL)
+  {
+    return MEMCACHED_INVALID_ARGUMENTS;
+  }
+
   /* All should be set, or none should be set */
-  if (mem_malloc == NULL && mem_free == NULL && mem_realloc == NULL && mem_calloc == NULL) 
+  if (mem_malloc == NULL and mem_free == NULL and mem_realloc == NULL and mem_calloc == NULL) 
   {
-    ptr->allocators= memcached_allocators_return_default();
+    self->allocators= memcached_allocators_return_default();
   }
-  else if (mem_malloc == NULL || mem_free == NULL || mem_realloc == NULL || mem_calloc == NULL)
+  else if (mem_malloc == NULL or mem_free == NULL or mem_realloc == NULL or mem_calloc == NULL)
   {
-    return MEMCACHED_FAILURE;
+    return memcached_set_error(*self, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, memcached_literal_param("NULL parameter provided for one or more allocators"));
   }
   else
   {
-    ptr->allocators.malloc= mem_malloc;
-    ptr->allocators.free= mem_free;
-    ptr->allocators.realloc= mem_realloc;
-    ptr->allocators.calloc= mem_calloc;
-    ptr->allocators.context= context;
+    self->allocators.malloc= mem_malloc;
+    self->allocators.free= mem_free;
+    self->allocators.realloc= mem_realloc;
+    self->allocators.calloc= mem_calloc;
+    self->allocators.context= context;
   }
 
   return MEMCACHED_SUCCESS;
 }
 
-void *memcached_get_memory_allocators_context(const memcached_st *ptr)
+void *memcached_get_memory_allocators_context(const memcached_st *shell)
 {
-  return ptr->allocators.context;
+  const Memcached* self= memcached2Memcached(shell);
+  if (self)
+  {
+    return self->allocators.context;
+  }
+
+  return NULL;
 }
 
-void memcached_get_memory_allocators(const memcached_st *ptr,
+void memcached_get_memory_allocators(const memcached_st *shell,
                                      memcached_malloc_fn *mem_malloc,
                                      memcached_free_fn *mem_free,
                                      memcached_realloc_fn *mem_realloc,
                                      memcached_calloc_fn *mem_calloc)
 {
-   *mem_malloc= ptr->allocators.malloc;
-   *mem_free= ptr->allocators.free;
-   *mem_realloc= ptr->allocators.realloc;
-   *mem_calloc= ptr->allocators.calloc;
+  const Memcached* self= memcached2Memcached(shell);
+  if (self)
+  {
+    if (mem_malloc)
+    {
+      *mem_malloc= self->allocators.malloc;
+    }
+
+    if (mem_free)
+    {
+      *mem_free= self->allocators.free;
+    }
+
+    if (mem_realloc)
+    {
+      *mem_realloc= self->allocators.realloc;
+    }
+
+    if (mem_calloc)
+    {
+      *mem_calloc= self->allocators.calloc;
+    }
+  }
 }