// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE

#ifndef CPPTL_JSON_ALLOCATOR_H_INCLUDED
#define CPPTL_JSON_ALLOCATOR_H_INCLUDED

#include <cstring>
#include <memory>

#pragma pack(push, 8)

namespace Json {
template <typename T> class SecureAllocator {
public:
 // Type definitions
 using value_type = T;
 using pointer = T*;
 using const_pointer = const T*;
 using reference = T&;
 using const_reference = const T&;
 using size_type = std::size_t;
 using difference_type = std::ptrdiff_t;

 /**
 * Allocate memory for N items using the standard allocator.
 */
 pointer allocate(size_type n) {
 // allocate using "global operator new"
 return static_cast<pointer>(::operator new(n * sizeof(T)));
 }

 /**
 * Release memory which was allocated for N items at pointer P.
 *
 * The memory block is filled with zeroes before being released.
 * The pointer argument is tagged as "volatile" to prevent the
 * compiler optimizing out this critical step.
 */
 void deallocate(volatile pointer p, size_type n) {
 std::memset(p, 0, n * sizeof(T));
 // free using "global operator delete"
 ::operator delete(p);
 }

 /**
 * Construct an item in-place at pointer P.
 */
 template <typename... Args> void construct(pointer p, Args&&... args) {
 // construct using "placement new" and "perfect forwarding"
 ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...);
 }

 size_type max_size() const { return size_t(-1) / sizeof(T); }

 pointer address(reference x) const { return std::addressof(x); }

 const_pointer address(const_reference x) const { return std::addressof(x); }

 /**
 * Destroy an item in-place at pointer P.
 */
 void destroy(pointer p) {
 // destroy using "explicit destructor"
 p->~T();
 }

 // Boilerplate
 SecureAllocator() {}
 template <typename U> SecureAllocator(const SecureAllocator<U>&) {}
 template <typename U> struct rebind { using other = SecureAllocator<U>; };
};

template <typename T, typename U>
bool operator==(const SecureAllocator<T>&, const SecureAllocator<U>&) {
 return true;
}

template <typename T, typename U>
bool operator!=(const SecureAllocator<T>&, const SecureAllocator<U>&) {
 return false;
}

} // namespace Json

#pragma pack(pop)

#endif // CPPTL_JSON_ALLOCATOR_H_INCLUDED