@cpp.js/package-proj 1.0.0-beta.24 → 2.0.0-beta.1

package/proj.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/proj/nn.hpp

@@ -1,385 +0,0 @@
-#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))