#pragma once
/*
* Copyright (c) 2015 Dropbox, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <cassert>
#include <cstdlib>
#include <functional>
#include <memory>
#include <type_traits>
namespace dropbox {
namespace oxygen {
// Marker type and value for use by nn below.
struct i_promise_i_checked_for_null_t {};
static constexpr i_promise_i_checked_for_null_t i_promise_i_checked_for_null{};
// Helper to get the type pointed to by a raw or smart pointer. This can be
// explicitly
// specialized if need be to provide compatibility with user-defined smart
// pointers.
namespace nn_detail {
template <typename T> struct element_type {
using type = typename T::element_type;
};
template <typename Pointee> struct element_type<Pointee *> {
using type = Pointee;
};
}
template <typename PtrType> class nn;
// Trait to check whether a given type is a non-nullable pointer
template <typename T> struct is_nn : public std::false_type {};
template <typename PtrType>
struct is_nn<nn<PtrType>> : public std::true_type {};
/* nn<PtrType>
*
* Wrapper around a pointer that is guaranteed to not be null. This works with
* raw pointers
* as well as any smart pointer: nn<int *>, nn<shared_ptr<DbxTable>>,
* nn<unique_ptr<Foo>>,
* etc. An nn<PtrType> can be used just like a PtrType.
*
* An nn<PtrType> can be constructed from another nn<PtrType>, if the underlying
* type would
* allow such construction. For example, nn<shared_ptr<PtrType>> can be copied
* and moved, but
* nn<unique_ptr<PtrType>> can only be moved; an nn<unique_ptr<PtrType>> can be
* explicitly
* (but not implicitly) created from an nn<PtrType*>; implicit upcasts are
* allowed; and so on.
*
* Similarly, non-nullable pointers can be compared with regular or other
* non-nullable
* pointers, using the same rules as the underlying pointer types.
*
* This module also provides helpers for creating an nn<PtrType> from operations
* that would
* always return a non-null pointer: nn_make_unique, nn_make_shared,
* nn_shared_from_this, and
* nn_addr (a replacement for operator&).
*
* We abbreviate nn<unique_ptr> as nn_unique_ptr - it's a little more readable.
* Likewise,
* nn<shared_ptr> can be written as nn_shared_ptr.
*
* Finally, we define macros NN_CHECK_ASSERT and NN_CHECK_THROW, to convert a
* nullable pointer
* to a non-nullable pointer. At Dropbox, these use customized error-handling
* infrastructure
* and are in a separate file. We've included sample implementations here.
*/
template <typename PtrType> class nn {
public:
static_assert(!is_nn<PtrType>::value, "nn<nn<T>> is disallowed");
using element_type = typename nn_detail::element_type<PtrType>::type;
// Pass through calls to operator* and operator-> transparently
element_type &operator*() const { return *ptr; }
element_type *operator->() const { return &*ptr; }
// Expose the underlying PtrType
operator const PtrType &() const & { return ptr; }
operator PtrType &&() && { return std::move(ptr); }
// Trying to use the assignment operator to assign a nn<PtrType> to a PtrType
// using the
// above conversion functions hits an ambiguous resolution bug in clang:
// http://llvm.org/bugs/show_bug.cgi?id=18359
// While that exists, we can use these as simple ways of accessing the
// underlying type
// (instead of workarounds calling the operators explicitly or adding a
// constructor call).
const PtrType &as_nullable() const & { return ptr; }
PtrType &&as_nullable() && { return std::move(ptr); }
// Can't convert to bool (that would be silly). The explicit delete results in
// "value of type 'nn<...>' is not contextually convertible to 'bool'", rather
// than
// "no viable conversion", which is a bit more clear.
operator bool() const = delete;
// Explicitly deleted constructors. These help produce clearer error messages,
// as trying
// to use them will result in clang printing the whole line, including the
// comment.
nn(std::nullptr_t) = delete; // nullptr is not allowed here
nn &operator=(std::nullptr_t) = delete; // nullptr is not allowed here
nn(PtrType) = delete; // must use NN_CHECK_ASSERT or NN_CHECK_THROW
nn &operator=(PtrType) = delete; // must use NN_CHECK_ASSERT or NN_CHECK_THROW
//PROJ_DLL ~nn();
// Semi-private constructor for use by NN_CHECK_ macros.
explicit nn(i_promise_i_checked_for_null_t, const PtrType &arg) noexcept : ptr(arg) {
}
explicit nn(i_promise_i_checked_for_null_t, PtrType &&arg) noexcept
: ptr(std::move(arg)) {
}
// Type-converting move and copy constructor. We have four separate cases
// here, for
// implicit and explicit move and copy.
template <typename OtherType,
typename std::enable_if<
std::is_constructible<PtrType, OtherType>::value &&
!std::is_convertible<OtherType, PtrType>::value,
int>::type = 0>
explicit nn(const nn<OtherType> &other)
: ptr(other.operator const OtherType &()) {}
template <typename OtherType,
typename std::enable_if<
std::is_constructible<PtrType, OtherType>::value &&
!std::is_convertible<OtherType, PtrType>::value &&
!std::is_pointer<OtherType>::value,
int>::type = 0>
explicit nn(nn<OtherType> &&other)
: ptr(std::move(other).operator OtherType &&()) {}
template <typename OtherType,
typename std::enable_if<
std::is_convertible<OtherType, PtrType>::value, int>::type = 0>
nn(const nn<OtherType> &other) : ptr(other.operator const OtherType &()) {}
template <
typename OtherType,
typename std::enable_if<std::is_convertible<OtherType, PtrType>::value &&
!std::is_pointer<OtherType>::value,
int>::type = 0>
nn(nn<OtherType> &&other) : ptr(std::move(other).operator OtherType &&()) {}
// A type-converting move and copy assignment operator aren't necessary;
// writing
// "base_ptr = derived_ptr;" will run the type-converting constructor followed
// by the
// implicit move assignment operator.
// Two-argument constructor, designed for use with the shared_ptr aliasing
// constructor.
// This will not be instantiated if PtrType doesn't have a suitable
// constructor.
template <
typename OtherType,
typename std::enable_if<
std::is_constructible<PtrType, OtherType, element_type *>::value,
int>::type = 0>
nn(const nn<OtherType> &ownership_ptr, nn<element_type *> target_ptr)
: ptr(ownership_ptr.operator const OtherType &(), target_ptr) {}
// Comparisons. Other comparisons are implemented in terms of these.
template <typename L, typename R>
friend bool operator==(const nn<L> &, const R &);
template <typename L, typename R>
friend bool operator==(const L &, const nn<R> &);
template <typename L, typename R>
friend bool operator==(const nn<L> &, const nn<R> &);
template <typename L, typename R>
friend bool operator<(const nn<L> &, const R &);
template <typename L, typename R>
friend bool operator<(const L &, const nn<R> &);
template <typename L, typename R>
friend bool operator<(const nn<L> &, const nn<R> &);
// ostream operator
template <typename T>
friend std::ostream &operator<<(std::ostream &, const nn<T> &);
template <typename T = PtrType> element_type *get() const {
return ptr.get();
}
private:
// Backing pointer
PtrType ptr;
};
// Base comparisons - these are friends of nn<PtrType>, so they can access .ptr
// directly.
template <typename L, typename R> bool operator==(const nn<L> &l, const R &r) {
return l.ptr == r;
}
template <typename L, typename R> bool operator==(const L &l, const nn<R> &r) {
return l == r.ptr;
}
template <typename L, typename R>
bool operator==(const nn<L> &l, const nn<R> &r) {
return l.ptr == r.ptr;
}
template <typename L, typename R> bool operator<(const nn<L> &l, const R &r) {
return l.ptr < r;
}
template <typename L, typename R> bool operator<(const L &l, const nn<R> &r) {
return l < r.ptr;
}
template <typename L, typename R>
bool operator<(const nn<L> &l, const nn<R> &r) {
return l.ptr < r.ptr;
}
template <typename T>
std::ostream &operator<<(std::ostream &os, const nn<T> &p) {
return os << p.ptr;
}
#define NN_DERIVED_OPERATORS(op, base) \
template <typename L, typename R> \
bool operator op(const nn<L> &l, const R &r) { \
return base; \
} \
template <typename L, typename R> \
bool operator op(const L &l, const nn<R> &r) { \
return base; \
} \
template <typename L, typename R> \
bool operator op(const nn<L> &l, const nn<R> &r) { \
return base; \
}
NN_DERIVED_OPERATORS(>, r < l)
NN_DERIVED_OPERATORS(<=, !(l > r))
NN_DERIVED_OPERATORS(>=, !(l < r))
NN_DERIVED_OPERATORS(!=, !(l == r))
#undef NN_DERIVED_OPERATORS
// Convenience typedefs
template <typename T> using nn_unique_ptr = nn<std::unique_ptr<T>>;
template <typename T> using nn_shared_ptr = nn<std::shared_ptr<T>>;
template <typename T, typename... Args>
nn_unique_ptr<T> nn_make_unique(Args &&... args) {
return nn_unique_ptr<T>(
i_promise_i_checked_for_null,
std::unique_ptr<T>(new T(std::forward<Args>(args)...)));
}
template <typename T, typename... Args>
nn_shared_ptr<T> nn_make_shared(Args &&... args) {
return nn_shared_ptr<T>(i_promise_i_checked_for_null,
std::make_shared<T>(std::forward<Args>(args)...));
}
template <typename T>
class nn_enable_shared_from_this : public std::enable_shared_from_this<T> {
public:
using std::enable_shared_from_this<T>::enable_shared_from_this;
nn_shared_ptr<T> nn_shared_from_this() {
return nn_shared_ptr<T>(i_promise_i_checked_for_null,
this->shared_from_this());
}
nn_shared_ptr<const T> nn_shared_from_this() const {
return nn_shared_ptr<const T>(i_promise_i_checked_for_null,
this->shared_from_this());
}
};
template <typename T> nn<T *> nn_addr(T &object) {
return nn<T *>(i_promise_i_checked_for_null, &object);
}
template <typename T> nn<const T *> nn_addr(const T &object) {
return nn<const T *>(i_promise_i_checked_for_null, &object);
}
/* Non-nullable equivalents of shared_ptr's specialized casting functions.
* These convert through a shared_ptr since nn<shared_ptr<T>> lacks the
* ref-count-sharing cast
* constructor, but thanks to moves there shouldn't be any significant extra
* cost. */
template <typename T, typename U>
nn_shared_ptr<T> nn_static_pointer_cast(const nn_shared_ptr<U> &org_ptr) {
auto raw_ptr =
static_cast<typename nn_shared_ptr<T>::element_type *>(org_ptr.get());
std::shared_ptr<T> nullable_ptr(org_ptr.as_nullable(), raw_ptr);
return nn_shared_ptr<T>(i_promise_i_checked_for_null,
std::move(nullable_ptr));
}
template <typename T, typename U>
std::shared_ptr<T> nn_dynamic_pointer_cast(const nn_shared_ptr<U> &org_ptr) {
auto raw_ptr =
dynamic_cast<typename std::shared_ptr<T>::element_type *>(org_ptr.get());
if (!raw_ptr) {
return nullptr;
} else {
return std::shared_ptr<T>(org_ptr.as_nullable(), raw_ptr);
}
}
template <typename T, typename U>
nn_shared_ptr<T> nn_const_pointer_cast(const nn_shared_ptr<U> &org_ptr) {
auto raw_ptr =
const_cast<typename nn_shared_ptr<T>::element_type *>(org_ptr.get());
std::shared_ptr<T> nullable_ptr(org_ptr.as_nullable(), raw_ptr);
return nn_shared_ptr<T>(i_promise_i_checked_for_null,
std::move(nullable_ptr));
}
}
} /* end namespace dropbox::oxygen */
namespace std {
template <typename T> struct hash<::dropbox::oxygen::nn<T>> {
using argument_type = ::dropbox::oxygen::nn<T>;
using result_type = size_t;
result_type operator()(const argument_type &obj) const {
return std::hash<T>{}(obj.as_nullable());
}
};
}
/* These have to be macros because our internal versions invoke other macros
* that use
* __FILE__ and __LINE__, which we want to correctly point to the call site.
* We're looking
* forward to std::source_location :)
*
* The lambdas ensure that we only evaluate _e once.
*/
#include <stdexcept>
// NN_CHECK_ASSERT takes a pointer of type PT (e.g. raw pointer, std::shared_ptr
// or std::unique_ptr)
// and returns a non-nullable pointer of type nn<PT>.
// Triggers an assertion if expression evaluates to null.
#define NN_CHECK_ASSERT(_e) \
(([&](typename std::remove_reference<decltype(_e)>::type p) { \
/* note: assert() alone is not sufficient here, because it might be \
* compiled out. */ \
assert(p &&#_e " must not be null"); \
if (!p) \
std::abort(); \
return dropbox::oxygen::nn< \
typename std::remove_reference<decltype(p)>::type>( \
dropbox::oxygen::i_promise_i_checked_for_null, std::move(p)); \
})(_e))
// NN_CHECK_THROW takes a pointer of type PT (e.g. raw pointer, std::shared_ptr
// or std::unique_ptr)
// and returns a non-nullable pointer of type nn<PT>.
// Throws if expression evaluates to null.
#define NN_CHECK_THROW(_e) \
(([&](typename std::remove_reference<decltype(_e)>::type p) { \
if (!p) \
throw std::runtime_error(#_e " must not be null"); \
return dropbox::oxygen::nn< \
typename std::remove_reference<decltype(p)>::type>( \
dropbox::oxygen::i_promise_i_checked_for_null, std::move(p)); \
})(_e))