@nxtedition/rocksdb 5.2.21 → 5.2.28

package/deps/rocksdb/rocksdb/third-party/folly/folly/Traits.h

@@ -1,152 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#include <type_traits>
-#include <utility>
-
-namespace folly {
-
-#if !defined(_MSC_VER)
-template <class T>
-struct is_trivially_copyable
-    : std::integral_constant<bool, __has_trivial_copy(T)> {};
-#else
-template <class T>
-using is_trivially_copyable = std::is_trivially_copyable<T>;
-#endif
-
-/***
- *  _t
- *
- *  Instead of:
- *
- *    using decayed = typename std::decay<T>::type;
- *
- *  With the C++14 standard trait aliases, we could use:
- *
- *    using decayed = std::decay_t<T>;
- *
- *  Without them, we could use:
- *
- *    using decayed = _t<std::decay<T>>;
- *
- *  Also useful for any other library with template types having dependent
- *  member types named `type`, like the standard trait types.
- */
-template <typename T>
-using _t = typename T::type;
-
-/**
- *  type_t
- *
- *  A type alias for the first template type argument. `type_t` is useful for
- *  controlling class-template and function-template partial specialization.
- *
- *  Example:
- *
- *    template <typename Value>
- *    class Container {
- *     public:
- *      template <typename... Args>
- *      Container(
- *          type_t<in_place_t, decltype(Value(std::declval<Args>()...))>,
- *          Args&&...);
- *    };
- *
- *  void_t
- *
- *  A type alias for `void`. `void_t` is useful for controling class-template
- *  and function-template partial specialization.
- *
- *  Example:
- *
- *    // has_value_type<T>::value is true if T has a nested type `value_type`
- *    template <class T, class = void>
- *    struct has_value_type
- *        : std::false_type {};
- *
- *    template <class T>
- *    struct has_value_type<T, folly::void_t<typename T::value_type>>
- *        : std::true_type {};
- */
-
-/**
- * There is a bug in libstdc++, libc++, and MSVC's STL that causes it to
- * ignore unused template parameter arguments in template aliases and does not
- * cause substitution failures. This defect has been recorded here:
- * http://open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html#1558.
- *
- * This causes the implementation of std::void_t to be buggy, as it is likely
- * defined as something like the following:
- *
- *  template <typename...>
- *  using void_t = void;
- *
- * This causes the compiler to ignore all the template arguments and does not
- * help when one wants to cause substitution failures.  Rather declarations
- * which have void_t in orthogonal specializations are treated as the same.
- * For example, assuming the possible `T` types are only allowed to have
- * either the alias `one` or `two` and never both or none:
- *
- *  template <typename T,
- *            typename std::void_t<std::decay_t<T>::one>* = nullptr>
- *  void foo(T&&) {}
- *  template <typename T,
- *            typename std::void_t<std::decay_t<T>::two>* = nullptr>
- *  void foo(T&&) {}
- *
- * The second foo() will be a redefinition because it conflicts with the first
- * one; void_t does not cause substitution failures - the template types are
- * just ignored.
- */
-
-namespace traits_detail {
-template <class T, class...>
-struct type_t_ {
-  using type = T;
-};
-} // namespace traits_detail
-
-template <class T, class... Ts>
-using type_t = typename traits_detail::type_t_<T, Ts...>::type;
-template <class... Ts>
-using void_t = type_t<void, Ts...>;
-
-/**
- * A type trait to remove all const volatile and reference qualifiers on a
- * type T
- */
-template <typename T>
-struct remove_cvref {
-  using type =
-      typename std::remove_cv<typename std::remove_reference<T>::type>::type;
-};
-template <typename T>
-using remove_cvref_t = typename remove_cvref<T>::type;
-
-template <class T>
-struct IsNothrowSwappable
-    : std::integral_constant<
-          bool,
-          std::is_nothrow_move_constructible<T>::value&& noexcept(
-              std::swap(std::declval<T&>(), std::declval<T&>()))> {};
-
-template <typename...>
-struct Conjunction : std::true_type {};
-template <typename T>
-struct Conjunction<T> : T {};
-template <typename T, typename... TList>
-struct Conjunction<T, TList...>
-    : std::conditional<T::value, Conjunction<TList...>, T>::type {};
-
-template <typename T>
-struct Negation : std::integral_constant<bool, !T::value> {};
-
-template <std::size_t I>
-using index_constant = std::integral_constant<std::size_t, I>;
-
-} // namespace folly

package/deps/rocksdb/rocksdb/third-party/folly/folly/Unit.h

@@ -1,59 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#include <type_traits>
-
-namespace folly {
-
-/// In functional programming, the degenerate case is often called "unit". In
-/// C++, "void" is often the best analogue. However, because of the syntactic
-/// special-casing required for void, it is frequently a liability for template
-/// metaprogramming. So, instead of writing specializations to handle cases like
-/// SomeContainer<void>, a library author may instead rule that out and simply
-/// have library users use SomeContainer<Unit>. Contained values may be ignored.
-/// Much easier.
-///
-/// "void" is the type that admits of no values at all. It is not possible to
-/// construct a value of this type.
-/// "unit" is the type that admits of precisely one unique value. It is
-/// possible to construct a value of this type, but it is always the same value
-/// every time, so it is uninteresting.
-struct Unit {
-  constexpr bool operator==(const Unit& /*other*/) const {
-    return true;
-  }
-  constexpr bool operator!=(const Unit& /*other*/) const {
-    return false;
-  }
-};
-
-constexpr Unit unit{};
-
-template <typename T>
-struct lift_unit {
-  using type = T;
-};
-template <>
-struct lift_unit<void> {
-  using type = Unit;
-};
-template <typename T>
-using lift_unit_t = typename lift_unit<T>::type;
-
-template <typename T>
-struct drop_unit {
-  using type = T;
-};
-template <>
-struct drop_unit<Unit> {
-  using type = void;
-};
-template <typename T>
-using drop_unit_t = typename drop_unit<T>::type;
-
-} // namespace folly
-

package/deps/rocksdb/rocksdb/third-party/folly/folly/Utility.h

@@ -1,141 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#include <utility>
-#include <type_traits>
-
-namespace folly {
-
-/**
- *  Backports from C++17 of:
- *    std::in_place_t
- *    std::in_place_type_t
- *    std::in_place_index_t
- *    std::in_place
- *    std::in_place_type
- *    std::in_place_index
- */
-
-struct in_place_tag {};
-template <class>
-struct in_place_type_tag {};
-template <std::size_t>
-struct in_place_index_tag {};
-
-using in_place_t = in_place_tag (&)(in_place_tag);
-template <class T>
-using in_place_type_t = in_place_type_tag<T> (&)(in_place_type_tag<T>);
-template <std::size_t I>
-using in_place_index_t = in_place_index_tag<I> (&)(in_place_index_tag<I>);
-
-inline in_place_tag in_place(in_place_tag = {}) {
-  return {};
-}
-template <class T>
-inline in_place_type_tag<T> in_place_type(in_place_type_tag<T> = {}) {
-  return {};
-}
-template <std::size_t I>
-inline in_place_index_tag<I> in_place_index(in_place_index_tag<I> = {}) {
-  return {};
-}
-
-template <class T, class U = T>
-T exchange(T& obj, U&& new_value) {
-  T old_value = std::move(obj);
-  obj = std::forward<U>(new_value);
-  return old_value;
-}
-
-namespace utility_detail {
-template <typename...>
-struct make_seq_cat;
-template <
-    template <typename T, T...> class S,
-    typename T,
-    T... Ta,
-    T... Tb,
-    T... Tc>
-struct make_seq_cat<S<T, Ta...>, S<T, Tb...>, S<T, Tc...>> {
-  using type =
-      S<T,
-        Ta...,
-        (sizeof...(Ta) + Tb)...,
-        (sizeof...(Ta) + sizeof...(Tb) + Tc)...>;
-};
-
-// Not parameterizing by `template <typename T, T...> class, typename` because
-// clang precisely v4.0 fails to compile that. Note that clang v3.9 and v5.0
-// handle that code correctly.
-//
-// For this to work, `S0` is required to be `Sequence<T>` and `S1` is required
-// to be `Sequence<T, 0>`.
-
-template <std::size_t Size>
-struct make_seq {
-  template <typename S0, typename S1>
-  using apply = typename make_seq_cat<
-      typename make_seq<Size / 2>::template apply<S0, S1>,
-      typename make_seq<Size / 2>::template apply<S0, S1>,
-      typename make_seq<Size % 2>::template apply<S0, S1>>::type;
-};
-template <>
-struct make_seq<1> {
-  template <typename S0, typename S1>
-  using apply = S1;
-};
-template <>
-struct make_seq<0> {
-  template <typename S0, typename S1>
-  using apply = S0;
-};
-} // namespace utility_detail
-
-// TODO: Remove after upgrading to C++14 baseline
-
-template <class T, T... Ints>
-struct integer_sequence {
-  using value_type = T;
-
-  static constexpr std::size_t size() noexcept {
-    return sizeof...(Ints);
-  }
-};
-
-template <std::size_t... Ints>
-using index_sequence = integer_sequence<std::size_t, Ints...>;
-
-template <typename T, std::size_t Size>
-using make_integer_sequence = typename utility_detail::make_seq<
-    Size>::template apply<integer_sequence<T>, integer_sequence<T, 0>>;
-
-template <std::size_t Size>
-using make_index_sequence = make_integer_sequence<std::size_t, Size>;
-template <class... T>
-using index_sequence_for = make_index_sequence<sizeof...(T)>;
-
-/**
- * A simple helper for getting a constant reference to an object.
- *
- * Example:
- *
- *   std::vector<int> v{1,2,3};
- *   // The following two lines are equivalent:
- *   auto a = const_cast<const std::vector<int>&>(v).begin();
- *   auto b = folly::as_const(v).begin();
- *
- * Like C++17's std::as_const. See http://wg21.link/p0007
- */
-template <class T>
-T const& as_const(T& t) noexcept {
-  return t;
-}
-
-template <class T>
-void as_const(T const&&) = delete;
-
-} // namespace folly

package/deps/rocksdb/rocksdb/third-party/folly/folly/chrono/Hardware.h

@@ -1,33 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#include <folly/Portability.h>
-
-#include <chrono>
-#include <cstdint>
-
-#if _MSC_VER && (defined(_M_IX86) || defined(_M_X64))
-extern "C" std::uint64_t __rdtsc();
-#pragma intrinsic(__rdtsc)
-#endif
-
-namespace folly {
-
-inline std::uint64_t hardware_timestamp() {
-#if _MSC_VER && (defined(_M_IX86) || defined(_M_X64))
-  return __rdtsc();
-#elif __GNUC__ && (__i386__ || FOLLY_X64)
-  return __builtin_ia32_rdtsc();
-#else
-  // use steady_clock::now() as an approximation for the timestamp counter on
-  // non-x86 systems
-  return std::chrono::steady_clock::now().time_since_epoch().count();
-#endif
-}
-
-} // namespace folly
-

package/deps/rocksdb/rocksdb/third-party/folly/folly/container/Array.h

@@ -1,74 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#include <array>
-#include <type_traits>
-#include <utility>
-
-#include <folly/Traits.h>
-#include <folly/Utility.h>
-
-namespace folly {
-
-namespace array_detail {
-template <typename>
-struct is_ref_wrapper : std::false_type {};
-template <typename T>
-struct is_ref_wrapper<std::reference_wrapper<T>> : std::true_type {};
-
-template <typename T>
-using not_ref_wrapper =
-    folly::Negation<is_ref_wrapper<typename std::decay<T>::type>>;
-
-template <typename D, typename...>
-struct return_type_helper {
-  using type = D;
-};
-template <typename... TList>
-struct return_type_helper<void, TList...> {
-  static_assert(
-      folly::Conjunction<not_ref_wrapper<TList>...>::value,
-      "TList cannot contain reference_wrappers when D is void");
-  using type = typename std::common_type<TList...>::type;
-};
-
-template <typename D, typename... TList>
-using return_type = std::
-    array<typename return_type_helper<D, TList...>::type, sizeof...(TList)>;
-} // namespace array_detail
-
-template <typename D = void, typename... TList>
-constexpr array_detail::return_type<D, TList...> make_array(TList&&... t) {
-  using value_type =
-      typename array_detail::return_type_helper<D, TList...>::type;
-  return {{static_cast<value_type>(std::forward<TList>(t))...}};
-}
-
-namespace array_detail {
-template <typename MakeItem, std::size_t... Index>
-inline constexpr auto make_array_with(
-    MakeItem const& make,
-    folly::index_sequence<Index...>)
-      -> std::array<decltype(make(0)), sizeof...(Index)> {
-  return std::array<decltype(make(0)), sizeof...(Index)>{{make(Index)...}};
-}
-} // namespace array_detail
-
-//  make_array_with
-//
-//  Constructs a std::array<..., Size> with elements m(i) for i in [0, Size).
-template <std::size_t Size, typename MakeItem>
-constexpr auto make_array_with(MakeItem const& make)
-    -> decltype(array_detail::make_array_with(
-          make,
-          folly::make_index_sequence<Size>{})) {
-  return array_detail::make_array_with(
-      make,
-      folly::make_index_sequence<Size>{});
-}
-
-} // namespace folly

package/deps/rocksdb/rocksdb/third-party/folly/folly/detail/Futex-inl.h

@@ -1,117 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#include <folly/detail/Futex.h>
-#include <folly/synchronization/ParkingLot.h>
-
-namespace folly {
-namespace detail {
-
-/** Optimal when TargetClock is the same type as Clock.
- *
- *  Otherwise, both Clock::now() and TargetClock::now() must be invoked. */
-template <typename TargetClock, typename Clock, typename Duration>
-typename TargetClock::time_point time_point_conv(
-    std::chrono::time_point<Clock, Duration> const& time) {
-  using std::chrono::duration_cast;
-  using TimePoint = std::chrono::time_point<Clock, Duration>;
-  using TargetDuration = typename TargetClock::duration;
-  using TargetTimePoint = typename TargetClock::time_point;
-  if (time == TimePoint::max()) {
-    return TargetTimePoint::max();
-  } else if (std::is_same<Clock, TargetClock>::value) {
-    // in place of time_point_cast, which cannot compile without if-constexpr
-    auto const delta = time.time_since_epoch();
-    return TargetTimePoint(duration_cast<TargetDuration>(delta));
-  } else {
-    // different clocks with different epochs, so non-optimal case
-    auto const delta = time - Clock::now();
-    return TargetClock::now() + duration_cast<TargetDuration>(delta);
-  }
-}
-
-/**
- * Available overloads, with definitions elsewhere
- *
- * These functions are treated as ADL-extension points, the templates above
- * call these functions without them having being pre-declared.  This works
- * because ADL lookup finds the definitions of these functions when you pass
- * the relevant arguments
- */
-int futexWakeImpl(
-    const Futex<std::atomic>* futex,
-    int count,
-    uint32_t wakeMask);
-FutexResult futexWaitImpl(
-    const Futex<std::atomic>* futex,
-    uint32_t expected,
-    std::chrono::system_clock::time_point const* absSystemTime,
-    std::chrono::steady_clock::time_point const* absSteadyTime,
-    uint32_t waitMask);
-
-int futexWakeImpl(
-    const Futex<EmulatedFutexAtomic>* futex,
-    int count,
-    uint32_t wakeMask);
-FutexResult futexWaitImpl(
-    const Futex<EmulatedFutexAtomic>* futex,
-    uint32_t expected,
-    std::chrono::system_clock::time_point const* absSystemTime,
-    std::chrono::steady_clock::time_point const* absSteadyTime,
-    uint32_t waitMask);
-
-template <typename Futex, typename Deadline>
-typename std::enable_if<Deadline::clock::is_steady, FutexResult>::type
-futexWaitImpl(
-    Futex* futex,
-    uint32_t expected,
-    Deadline const& deadline,
-    uint32_t waitMask) {
-  return futexWaitImpl(futex, expected, nullptr, &deadline, waitMask);
-}
-
-template <typename Futex, typename Deadline>
-typename std::enable_if<!Deadline::clock::is_steady, FutexResult>::type
-futexWaitImpl(
-    Futex* futex,
-    uint32_t expected,
-    Deadline const& deadline,
-    uint32_t waitMask) {
-  return futexWaitImpl(futex, expected, &deadline, nullptr, waitMask);
-}
-
-template <typename Futex>
-FutexResult
-futexWait(const Futex* futex, uint32_t expected, uint32_t waitMask) {
-  auto rv = futexWaitImpl(futex, expected, nullptr, nullptr, waitMask);
-  assert(rv != FutexResult::TIMEDOUT);
-  return rv;
-}
-
-template <typename Futex>
-int futexWake(const Futex* futex, int count, uint32_t wakeMask) {
-  return futexWakeImpl(futex, count, wakeMask);
-}
-
-template <typename Futex, class Clock, class Duration>
-FutexResult futexWaitUntil(
-    const Futex* futex,
-    uint32_t expected,
-    std::chrono::time_point<Clock, Duration> const& deadline,
-    uint32_t waitMask) {
-  using Target = typename std::conditional<
-      Clock::is_steady,
-      std::chrono::steady_clock,
-      std::chrono::system_clock>::type;
-  auto const converted = time_point_conv<Target>(deadline);
-  return converted == Target::time_point::max()
-      ? futexWaitImpl(futex, expected, nullptr, nullptr, waitMask)
-      : futexWaitImpl(futex, expected, converted, waitMask);
-}
-
-} // namespace detail
-} // namespace folly