1//===----------------------------------------------------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is dual licensed under the MIT and the University of Illinois Open
6// Source Licenses. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef MIN_ALLOCATOR_H
11#define MIN_ALLOCATOR_H
12
13#if __cplusplus >= 201103L
14
15#include <memory>
16
17template <class T> class min_pointer;
18template <class T> class min_pointer<const T>;
19template <> class min_pointer<void>;
20template <> class min_pointer<const void>;
21template <class T> class min_allocator;
22
23template <>
24class min_pointer<const void>
25{
26    const void* ptr_;
27public:
28    min_pointer() noexcept = default;
29    min_pointer(std::nullptr_t) : ptr_(nullptr) {}
30    template <class T>
31    min_pointer(min_pointer<T> p) : ptr_(p.ptr_) {}
32
33    explicit operator bool() const {return ptr_ != nullptr;}
34
35    friend bool operator==(min_pointer x, min_pointer y) {return x.ptr_ == y.ptr_;}
36    friend bool operator!=(min_pointer x, min_pointer y) {return !(x == y);}
37    template <class U> friend class min_pointer;
38};
39
40template <>
41class min_pointer<void>
42{
43    void* ptr_;
44public:
45    min_pointer() noexcept = default;
46    min_pointer(std::nullptr_t) : ptr_(nullptr) {}
47    template <class T,
48              class = typename std::enable_if
49                       <
50                            !std::is_const<T>::value
51                       >::type
52             >
53    min_pointer(min_pointer<T> p) : ptr_(p.ptr_) {}
54
55    explicit operator bool() const {return ptr_ != nullptr;}
56
57    friend bool operator==(min_pointer x, min_pointer y) {return x.ptr_ == y.ptr_;}
58    friend bool operator!=(min_pointer x, min_pointer y) {return !(x == y);}
59    template <class U> friend class min_pointer;
60};
61
62template <class T>
63class min_pointer
64{
65    T* ptr_;
66
67    explicit min_pointer(T* p) : ptr_(p) {}
68public:
69    min_pointer() noexcept = default;
70    min_pointer(std::nullptr_t) : ptr_(nullptr) {}
71    explicit min_pointer(min_pointer<void> p) : ptr_(static_cast<T*>(p.ptr_)) {}
72
73    explicit operator bool() const {return ptr_ != nullptr;}
74
75    typedef std::ptrdiff_t difference_type;
76    typedef T& reference;
77    typedef T* pointer;
78    typedef T value_type;
79    typedef std::random_access_iterator_tag iterator_category;
80
81    reference operator*() const {return *ptr_;}
82    pointer operator->() const {return ptr_;}
83
84    min_pointer& operator++() {++ptr_; return *this;}
85    min_pointer operator++(int) {min_pointer tmp(*this); ++ptr_; return tmp;}
86
87    min_pointer& operator--() {--ptr_; return *this;}
88    min_pointer operator--(int) {min_pointer tmp(*this); --ptr_; return tmp;}
89
90    min_pointer& operator+=(difference_type n) {ptr_ += n; return *this;}
91    min_pointer& operator-=(difference_type n) {ptr_ -= n; return *this;}
92
93    min_pointer operator+(difference_type n) const
94    {
95        min_pointer tmp(*this);
96        tmp += n;
97        return tmp;
98    }
99
100    friend min_pointer operator+(difference_type n, min_pointer x)
101    {
102        return x + n;
103    }
104
105    min_pointer operator-(difference_type n) const
106    {
107        min_pointer tmp(*this);
108        tmp -= n;
109        return tmp;
110    }
111
112    friend difference_type operator-(min_pointer x, min_pointer y)
113    {
114        return x.ptr_ - y.ptr_;
115    }
116
117    reference operator[](difference_type n) const {return ptr_[n];}
118
119    friend bool operator< (min_pointer x, min_pointer y) {return x.ptr_ < y.ptr_;}
120    friend bool operator> (min_pointer x, min_pointer y) {return y < x;}
121    friend bool operator<=(min_pointer x, min_pointer y) {return !(y < x);}
122    friend bool operator>=(min_pointer x, min_pointer y) {return !(x < y);}
123
124    static min_pointer pointer_to(T& t) {return min_pointer(std::addressof(t));}
125
126    friend bool operator==(min_pointer x, min_pointer y) {return x.ptr_ == y.ptr_;}
127    friend bool operator!=(min_pointer x, min_pointer y) {return !(x == y);}
128    template <class U> friend class min_pointer;
129    template <class U> friend class min_allocator;
130};
131
132template <class T>
133class min_pointer<const T>
134{
135    const T* ptr_;
136
137    explicit min_pointer(const T* p) : ptr_(p) {}
138public:
139    min_pointer() noexcept = default;
140    min_pointer(std::nullptr_t) : ptr_(nullptr) {}
141    min_pointer(min_pointer<T> p) : ptr_(p.ptr_) {}
142    explicit min_pointer(min_pointer<const void> p) : ptr_(static_cast<const T*>(p.ptr_)) {}
143
144    explicit operator bool() const {return ptr_ != nullptr;}
145
146    typedef std::ptrdiff_t difference_type;
147    typedef const T& reference;
148    typedef const T* pointer;
149    typedef const T value_type;
150    typedef std::random_access_iterator_tag iterator_category;
151
152    reference operator*() const {return *ptr_;}
153    pointer operator->() const {return ptr_;}
154
155    min_pointer& operator++() {++ptr_; return *this;}
156    min_pointer operator++(int) {min_pointer tmp(*this); ++ptr_; return tmp;}
157
158    min_pointer& operator--() {--ptr_; return *this;}
159    min_pointer operator--(int) {min_pointer tmp(*this); --ptr_; return tmp;}
160
161    min_pointer& operator+=(difference_type n) {ptr_ += n; return *this;}
162    min_pointer& operator-=(difference_type n) {ptr_ -= n; return *this;}
163
164    min_pointer operator+(difference_type n) const
165    {
166        min_pointer tmp(*this);
167        tmp += n;
168        return tmp;
169    }
170
171    friend min_pointer operator+(difference_type n, min_pointer x)
172    {
173        return x + n;
174    }
175
176    min_pointer operator-(difference_type n) const
177    {
178        min_pointer tmp(*this);
179        tmp -= n;
180        return tmp;
181    }
182
183    friend difference_type operator-(min_pointer x, min_pointer y)
184    {
185        return x.ptr_ - y.ptr_;
186    }
187
188    reference operator[](difference_type n) const {return ptr_[n];}
189
190    friend bool operator< (min_pointer x, min_pointer y) {return x.ptr_ < y.ptr_;}
191    friend bool operator> (min_pointer x, min_pointer y) {return y < x;}
192    friend bool operator<=(min_pointer x, min_pointer y) {return !(y < x);}
193    friend bool operator>=(min_pointer x, min_pointer y) {return !(x < y);}
194
195    static min_pointer pointer_to(const T& t) {return min_pointer(std::addressof(t));}
196
197    friend bool operator==(min_pointer x, min_pointer y) {return x.ptr_ == y.ptr_;}
198    friend bool operator!=(min_pointer x, min_pointer y) {return !(x == y);}
199    template <class U> friend class min_pointer;
200};
201
202template <class T>
203inline
204bool
205operator==(min_pointer<T> x, std::nullptr_t)
206{
207    return !static_cast<bool>(x);
208}
209
210template <class T>
211inline
212bool
213operator==(std::nullptr_t, min_pointer<T> x)
214{
215    return !static_cast<bool>(x);
216}
217
218template <class T>
219inline
220bool
221operator!=(min_pointer<T> x, std::nullptr_t)
222{
223    return static_cast<bool>(x);
224}
225
226template <class T>
227inline
228bool
229operator!=(std::nullptr_t, min_pointer<T> x)
230{
231    return static_cast<bool>(x);
232}
233
234template <class T>
235class min_allocator
236{
237public:
238    typedef T value_type;
239    typedef min_pointer<T> pointer;
240
241    min_allocator() = default;
242    template <class U>
243    min_allocator(min_allocator<U>) {}
244
245    pointer allocate(std::ptrdiff_t n)
246    {
247        return pointer(static_cast<T*>(::operator new(n*sizeof(T))));
248    }
249
250    void deallocate(pointer p, std::ptrdiff_t)
251    {
252        return ::operator delete(p.ptr_);
253    }
254
255    friend bool operator==(min_allocator, min_allocator) {return true;}
256    friend bool operator!=(min_allocator x, min_allocator y) {return !(x == y);}
257};
258
259#endif  // __cplusplus >= 201103L
260
261#endif  // MIN_ALLOCATOR_H
262