Merge branch 'add_std_prefix'

Conflicts:
	include/msgpack/adaptor/char_ptr.hpp
	include/msgpack/adaptor/string.hpp

Author: nobu-k

include/msgpack/adaptor/char_ptr.hpp

@@ -44,7 +44,7 @@ inline void operator<< (object::with_zone& o, const char* v)
     char* ptr = static_cast<char*>(o.zone.allocate_align(size));
     o.via.str.ptr = ptr;
     o.via.str.size = size;
-    memcpy(ptr, v, size);
+    std::memcpy(ptr, v, size);
 }
 
 inline void operator<< (object& o, const char* v)

include/msgpack/adaptor/raw.hpp

@@ -40,7 +40,7 @@ struct raw_ref {
 
     bool operator== (const raw_ref& x) const
     {
-        return size == x.size && memcmp(ptr, x.ptr, size) == 0;
+        return size == x.size && std::memcmp(ptr, x.ptr, size) == 0;
     }
 
     bool operator!= (const raw_ref& x) const
@@ -50,13 +50,13 @@ struct raw_ref {
 
     bool operator< (const raw_ref& x) const
     {
-        if(size == x.size) { return memcmp(ptr, x.ptr, size) < 0; }
+        if(size == x.size) { return std::memcmp(ptr, x.ptr, size) < 0; }
         else { return size < x.size; }
     }
 
     bool operator> (const raw_ref& x) const
     {
-        if(size == x.size) { return memcmp(ptr, x.ptr, size) > 0; }
+        if(size == x.size) { return std::memcmp(ptr, x.ptr, size) > 0; }
         else { return size > x.size; }
     }
 };

include/msgpack/adaptor/string.hpp

@@ -60,7 +60,7 @@ inline void operator<< (object::with_zone& o, const std::string& v)
     char* ptr = static_cast<char*>(o.zone.allocate_align(size));
     o.via.str.ptr = ptr;
     o.via.str.size = size;
-    memcpy(ptr, v.data(), size);
+    std::memcpy(ptr, v.data(), v.size());
 }
 
 inline void operator<< (object& o, const std::string& v)

include/msgpack/object.hpp

@@ -212,30 +212,30 @@ inline void operator<< (object::with_zone& o, const object& v)
     case type::POSITIVE_INTEGER:
     case type::NEGATIVE_INTEGER:
     case type::FLOAT:
-        ::memcpy(&o.via, &v.via, sizeof(v.via));
+        std::memcpy(&o.via, &v.via, sizeof(v.via));
         return;
 
     case type::STR: {
         char* ptr = static_cast<char*>(o.zone.allocate_align(v.via.str.size));
         o.via.str.ptr = ptr;
         o.via.str.size = v.via.str.size;
-        ::memcpy(ptr, v.via.str.ptr, v.via.str.size);
+        std::memcpy(ptr, v.via.str.ptr, v.via.str.size);
         return;
     }
 
     case type::BIN: {
         char* ptr = static_cast<char*>(o.zone.allocate_align(v.via.bin.size));
         o.via.bin.ptr = ptr;
         o.via.bin.size = v.via.bin.size;
-        ::memcpy(ptr, v.via.bin.ptr, v.via.bin.size);
+        std::memcpy(ptr, v.via.bin.ptr, v.via.bin.size);
         return;
     }
 
     case type::EXT: {
         char* ptr = static_cast<char*>(o.zone.allocate_align(v.via.ext.size + 1));
         o.via.ext.ptr = ptr;
         o.via.ext.size = v.via.ext.size;
-        ::memcpy(ptr, v.via.ext.ptr, v.via.ext.size + 1);
+        std::memcpy(ptr, v.via.ext.ptr, v.via.ext.size + 1);
         return;
     }
 
@@ -347,15 +347,15 @@ inline bool operator==(const object& x, const object& y)
 
     case type::STR:
         return x.via.str.size == y.via.str.size &&
-            memcmp(x.via.str.ptr, y.via.str.ptr, x.via.str.size) == 0;
+            std::memcmp(x.via.str.ptr, y.via.str.ptr, x.via.str.size) == 0;
 
     case type::BIN:
         return x.via.bin.size == y.via.bin.size &&
-            memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0;
+            std::memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0;
 
     case type::EXT:
         return x.via.ext.size == y.via.ext.size &&
-            memcmp(x.via.ext.ptr, y.via.ext.ptr, x.via.ext.size) == 0;
+            std::memcmp(x.via.ext.ptr, y.via.ext.ptr, x.via.ext.size) == 0;
 
     case type::ARRAY:
         if(x.via.array.size != y.via.array.size) {
@@ -526,20 +526,20 @@ object::object(const T& v, zone* z)
 inline object::object(msgpack_object o)
 {
     // FIXME beter way?
-    ::memcpy(this, &o, sizeof(o));
+    std::memcpy(this, &o, sizeof(o));
 }
 
 inline void operator<< (object& o, msgpack_object v)
 {
     // FIXME beter way?
-    ::memcpy(&o, &v, sizeof(v));
+    std::memcpy(&o, &v, sizeof(v));
 }
 
 inline object::operator msgpack_object() const
 {
     // FIXME beter way?
     msgpack_object obj;
-    ::memcpy(&obj, this, sizeof(obj));
+    std::memcpy(&obj, this, sizeof(obj));
     return obj;
 }
 

include/msgpack/sbuffer.hpp

@@ -55,7 +55,7 @@ class sbuffer {
         if(m_alloc - m_size < len) {
             expand_buffer(len);
         }
-        ::memcpy(m_data + m_size, buf, len);
+        std::memcpy(m_data + m_size, buf, len);
         m_size += len;
     }
 

include/msgpack/vrefbuffer.hpp

@@ -160,7 +160,7 @@ class vrefbuffer {
         }
 
         char* m = ib->ptr;
-        ::memcpy(m, buf, len);
+        std::memcpy(m, buf, len);
         ib->free -= len;
         ib->ptr      += len;
 
@@ -222,7 +222,7 @@ class vrefbuffer {
             to->m_tail  = nvec + tosize;
         }
 
-        ::memcpy(to->m_tail, m_array, sizeof(iovec)*nused);
+        std::memcpy(to->m_tail, m_array, sizeof(iovec)*nused);
 
         to->m_tail += nused;
         m_tail = m_array;