include/json/allocator.h

Go to the documentation of this file.

// Copyright 2007-2010 Baptiste Lepilleur
// 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>

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;

      pointer allocate(size_type n) {
         // allocate using "global operator new"
         return static_cast<pointer>(::operator new(n * sizeof(T)));
      }

      void deallocate(volatile pointer p, size_type n) {
         std::memset(p, 0, n * sizeof(T));
         // free using "global operator delete"
         ::operator delete(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);
      }

      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

#endif // CPPTL_JSON_ALLOCATOR_H_INCLUDED