1 // Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors 2 // Distributed under MIT license, or public domain if desired and 3 // recognized in your jurisdiction. 4 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE 5 6 #ifndef JSON_ALLOCATOR_H_INCLUDED 7 #define JSON_ALLOCATOR_H_INCLUDED 8 9 #include <cstring> 10 #include <memory> 11 12 #pragma pack(push, 8) 13 14 namespace Json { 15 template <typename T> class SecureAllocator { 16 public: 17 // Type definitions 18 using value_type = T; 19 using pointer = T*; 20 using const_pointer = const T*; 21 using reference = T&; 22 using const_reference = const T&; 23 using size_type = std::size_t; 24 using difference_type = std::ptrdiff_t; 25 26 /** 27 * Allocate memory for N items using the standard allocator. 28 */ allocate(size_type n)29 pointer allocate(size_type n) { 30 // allocate using "global operator new" 31 return static_cast<pointer>(::operator new(n * sizeof(T))); 32 } 33 34 /** 35 * Release memory which was allocated for N items at pointer P. 36 * 37 * The memory block is filled with zeroes before being released. 38 */ deallocate(pointer p,size_type n)39 void deallocate(pointer p, size_type n) { 40 // memset_s is used because memset may be optimized away by the compiler 41 memset_s(p, n * sizeof(T), 0, n * sizeof(T)); 42 // free using "global operator delete" 43 ::operator delete(p); 44 } 45 46 /** 47 * Construct an item in-place at pointer P. 48 */ construct(pointer p,Args &&...args)49 template <typename... Args> void construct(pointer p, Args&&... args) { 50 // construct using "placement new" and "perfect forwarding" 51 ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...); 52 } 53 max_size()54 size_type max_size() const { return size_t(-1) / sizeof(T); } 55 address(reference x)56 pointer address(reference x) const { return std::addressof(x); } 57 address(const_reference x)58 const_pointer address(const_reference x) const { return std::addressof(x); } 59 60 /** 61 * Destroy an item in-place at pointer P. 62 */ destroy(pointer p)63 void destroy(pointer p) { 64 // destroy using "explicit destructor" 65 p->~T(); 66 } 67 68 // Boilerplate SecureAllocator()69 SecureAllocator() {} SecureAllocator(const SecureAllocator<U> &)70 template <typename U> SecureAllocator(const SecureAllocator<U>&) {} 71 template <typename U> struct rebind { using other = SecureAllocator<U>; }; 72 }; 73 74 template <typename T, typename U> 75 bool operator==(const SecureAllocator<T>&, const SecureAllocator<U>&) { 76 return true; 77 } 78 79 template <typename T, typename U> 80 bool operator!=(const SecureAllocator<T>&, const SecureAllocator<U>&) { 81 return false; 82 } 83 84 } // namespace Json 85 86 #pragma pack(pop) 87 88 #endif // JSON_ALLOCATOR_H_INCLUDED 89