update

wangzhengquan

2020-06-13 0defce43c97145172f10a5c114281e704820f95c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
// 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;
 
        /**
         * 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
 
#endif // CPPTL_JSON_ALLOCATOR_H_INCLUDED