1 /////////////////////////////////////////////////////////////////////////////// 2 // 3 // Copyright (c) 2015 Microsoft Corporation. All rights reserved. 4 // 5 // This code is licensed under the MIT License (MIT). 6 // 7 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 8 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 9 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 10 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 11 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 12 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 13 // THE SOFTWARE. 14 // 15 /////////////////////////////////////////////////////////////////////////////// 16 17 #ifndef GSL_POINTERS_H 18 #define GSL_POINTERS_H 19 20 #include <gsl/gsl_assert> // for Ensures, Expects 21 22 #include <algorithm> // for forward 23 #include <iosfwd> // for ptrdiff_t, nullptr_t, ostream, size_t 24 #include <memory> // for shared_ptr, unique_ptr 25 #include <system_error> // for hash 26 #include <type_traits> // for enable_if_t, is_convertible, is_assignable 27 28 #if defined(_MSC_VER) && _MSC_VER < 1910 && !defined(__clang__) 29 #pragma push_macro("constexpr") 30 #define constexpr /*constexpr*/ 31 32 #endif // defined(_MSC_VER) && _MSC_VER < 1910 33 34 namespace gsl 35 { 36 37 // 38 // GSL.owner: ownership pointers 39 // 40 using std::unique_ptr; 41 using std::shared_ptr; 42 43 // 44 // owner 45 // 46 // owner<T> is designed as a bridge for code that must deal directly with owning pointers for some reason 47 // 48 // T must be a pointer type 49 // - disallow construction from any type other than pointer type 50 // 51 template <class T, class = std::enable_if_t<std::is_pointer<T>::value>> 52 using owner = T; 53 54 // 55 // not_null 56 // 57 // Restricts a pointer or smart pointer to only hold non-null values. 58 // 59 // Has zero size overhead over T. 60 // 61 // If T is a pointer (i.e. T == U*) then 62 // - allow construction from U* 63 // - disallow construction from nullptr_t 64 // - disallow default construction 65 // - ensure construction from null U* fails 66 // - allow implicit conversion to U* 67 // 68 template <class T> 69 class not_null 70 { 71 public: 72 static_assert(std::is_assignable<T&, std::nullptr_t>::value, "T cannot be assigned nullptr."); 73 74 template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>> 75 constexpr not_null(U&& u) : ptr_(std::forward<U>(u)) 76 { 77 Expects(ptr_ != nullptr); 78 } 79 80 template <typename = std::enable_if_t<!std::is_same<std::nullptr_t, T>::value>> 81 constexpr not_null(T u) : ptr_(u) 82 { 83 Expects(ptr_ != nullptr); 84 } 85 86 template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>> 87 constexpr not_null(const not_null<U>& other) : not_null(other.get()) 88 { 89 } 90 91 not_null(not_null&& other) = default; 92 not_null(const not_null& other) = default; 93 not_null& operator=(const not_null& other) = default; 94 95 constexpr T get() const 96 { 97 Ensures(ptr_ != nullptr); 98 return ptr_; 99 } 100 101 constexpr operator T() const { return get(); } 102 constexpr T operator->() const { return get(); } 103 constexpr decltype(auto) operator*() const { return *get(); } 104 105 // prevents compilation when someone attempts to assign a null pointer constant 106 not_null(std::nullptr_t) = delete; 107 not_null& operator=(std::nullptr_t) = delete; 108 109 // unwanted operators...pointers only point to single objects! 110 not_null& operator++() = delete; 111 not_null& operator--() = delete; 112 not_null operator++(int) = delete; 113 not_null operator--(int) = delete; 114 not_null& operator+=(std::ptrdiff_t) = delete; 115 not_null& operator-=(std::ptrdiff_t) = delete; 116 void operator[](std::ptrdiff_t) const = delete; 117 118 private: 119 T ptr_; 120 }; 121 122 template <class T> 123 auto make_not_null(T&& t) { 124 return not_null<std::remove_cv_t<std::remove_reference_t<T>>>{std::forward<T>(t)}; 125 } 126 127 template <class T> 128 std::ostream& operator<<(std::ostream& os, const not_null<T>& val) 129 { 130 os << val.get(); 131 return os; 132 } 133 134 template <class T, class U> 135 auto operator==(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() == rhs.get()) 136 { 137 return lhs.get() == rhs.get(); 138 } 139 140 template <class T, class U> 141 auto operator!=(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() != rhs.get()) 142 { 143 return lhs.get() != rhs.get(); 144 } 145 146 template <class T, class U> 147 auto operator<(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() < rhs.get()) 148 { 149 return lhs.get() < rhs.get(); 150 } 151 152 template <class T, class U> 153 auto operator<=(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() <= rhs.get()) 154 { 155 return lhs.get() <= rhs.get(); 156 } 157 158 template <class T, class U> 159 auto operator>(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() > rhs.get()) 160 { 161 return lhs.get() > rhs.get(); 162 } 163 164 template <class T, class U> 165 auto operator>=(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() >= rhs.get()) 166 { 167 return lhs.get() >= rhs.get(); 168 } 169 170 // more unwanted operators 171 template <class T, class U> 172 std::ptrdiff_t operator-(const not_null<T>&, const not_null<U>&) = delete; 173 template <class T> 174 not_null<T> operator-(const not_null<T>&, std::ptrdiff_t) = delete; 175 template <class T> 176 not_null<T> operator+(const not_null<T>&, std::ptrdiff_t) = delete; 177 template <class T> 178 not_null<T> operator+(std::ptrdiff_t, const not_null<T>&) = delete; 179 180 } // namespace gsl 181 182 namespace std 183 { 184 template <class T> 185 struct hash<gsl::not_null<T>> 186 { 187 std::size_t operator()(const gsl::not_null<T>& value) const { return hash<T>{}(value); } 188 }; 189 190 } // namespace std 191 192 namespace gsl 193 { 194 195 // 196 // strict_not_null 197 // 198 // Restricts a pointer or smart pointer to only hold non-null values, 199 // 200 // - provides a strict (i.e. explicit contructor from T) wrapper of not_null 201 // - to be used for new code that wishes the design to be cleaner and make not_null 202 // checks intentional, or in old code that would like to make the transition. 203 // 204 // To make the transition from not_null, incrementally replace not_null 205 // by strict_not_null and fix compilation errors 206 // 207 // Expect to 208 // - remove all unneded conversions from raw pointer to not_null and back 209 // - make API clear by specifyning not_null in parameters where needed 210 // - remove unnesessary asserts 211 // 212 template <class T> 213 class strict_not_null: public not_null<T> 214 { 215 public: 216 217 template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>> 218 constexpr explicit strict_not_null(U&& u) : 219 not_null<T>(std::forward<U>(u)) 220 {} 221 222 template <typename = std::enable_if_t<!std::is_same<std::nullptr_t, T>::value>> 223 constexpr explicit strict_not_null(T u) : 224 not_null<T>(u) 225 {} 226 227 template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>> 228 constexpr strict_not_null(const not_null<U>& other) : 229 not_null<T>(other) 230 {} 231 232 template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>> 233 constexpr strict_not_null(const strict_not_null<U>& other) : 234 not_null<T>(other) 235 {} 236 237 strict_not_null(strict_not_null&& other) = default; 238 strict_not_null(const strict_not_null& other) = default; 239 strict_not_null& operator=(const strict_not_null& other) = default; 240 strict_not_null& operator=(const not_null<T>& other) 241 { 242 not_null<T>::operator=(other); 243 return *this; 244 } 245 246 // prevents compilation when someone attempts to assign a null pointer constant 247 strict_not_null(std::nullptr_t) = delete; 248 strict_not_null& operator=(std::nullptr_t) = delete; 249 250 // unwanted operators...pointers only point to single objects! 251 strict_not_null& operator++() = delete; 252 strict_not_null& operator--() = delete; 253 strict_not_null operator++(int) = delete; 254 strict_not_null operator--(int) = delete; 255 strict_not_null& operator+=(std::ptrdiff_t) = delete; 256 strict_not_null& operator-=(std::ptrdiff_t) = delete; 257 void operator[](std::ptrdiff_t) const = delete; 258 }; 259 260 // more unwanted operators 261 template <class T, class U> 262 std::ptrdiff_t operator-(const strict_not_null<T>&, const strict_not_null<U>&) = delete; 263 template <class T> 264 strict_not_null<T> operator-(const strict_not_null<T>&, std::ptrdiff_t) = delete; 265 template <class T> 266 strict_not_null<T> operator+(const strict_not_null<T>&, std::ptrdiff_t) = delete; 267 template <class T> 268 strict_not_null<T> operator+(std::ptrdiff_t, const strict_not_null<T>&) = delete; 269 270 template <class T> 271 auto make_strict_not_null(T&& t) { 272 return strict_not_null<std::remove_cv_t<std::remove_reference_t<T>>>{std::forward<T>(t)}; 273 } 274 275 } // namespace gsl 276 277 namespace std 278 { 279 template <class T> 280 struct hash<gsl::strict_not_null<T>> 281 { 282 std::size_t operator()(const gsl::strict_not_null<T>& value) const { return hash<T>{}(value); } 283 }; 284 285 } // namespace std 286 287 #if defined(_MSC_VER) && _MSC_VER < 1910 && !defined(__clang__) 288 289 #undef constexpr 290 #pragma pop_macro("constexpr") 291 292 #endif // defined(_MSC_VER) && _MSC_VER < 1910 && !defined(__clang__) 293 294 #endif // GSL_POINTERS_H 295
