[Bf-blender-cvs] [34c3d73da15] temp-trimesh-sculpt: okay that's better
Joseph Eagar
noreply at git.blender.org
Wed Oct 14 04:05:48 CEST 2020
Commit: 34c3d73da159f7f0eab906ce5b4293feb95bcab9
Author: Joseph Eagar
Date: Sun Oct 4 17:49:50 2020 -0700
Branches: temp-trimesh-sculpt
https://developer.blender.org/rB34c3d73da159f7f0eab906ce5b4293feb95bcab9
okay that's better
===================================================================
A extern/parallel-hashmap/btree.h
A extern/parallel-hashmap/conanfile.py
A extern/parallel-hashmap/meminfo.h
A extern/parallel-hashmap/phmap.h
A extern/parallel-hashmap/phmap_base.h
A extern/parallel-hashmap/phmap_bits.h
A extern/parallel-hashmap/phmap_config.h
A extern/parallel-hashmap/phmap_dump.h
A extern/parallel-hashmap/phmap_fwd_decl.h
A extern/parallel-hashmap/phmap_utils.h
===================================================================
diff --git a/extern/parallel-hashmap/btree.h b/extern/parallel-hashmap/btree.h
new file mode 100644
index 00000000000..7c73162d1c5
--- /dev/null
+++ b/extern/parallel-hashmap/btree.h
@@ -0,0 +1,4050 @@
+// ---------------------------------------------------------------------------
+// Copyright (c) 2019, Gregory Popovitch - greg7mdp at gmail.com
+//
+// 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
+//
+// https://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.
+//
+// Includes work from abseil-cpp (https://github.com/abseil/abseil-cpp)
+// with modifications.
+//
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+// https://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.
+// ---------------------------------------------------------------------------
+
+#ifndef PHMAP_BTREE_BTREE_CONTAINER_H_
+#define PHMAP_BTREE_BTREE_CONTAINER_H_
+
+#ifdef _MSC_VER
+ #pragma warning(push)
+
+ #pragma warning(disable : 4127) // conditional expression is constant
+ #pragma warning(disable : 4324) // structure was padded due to alignment specifier
+ #pragma warning(disable : 4355) // 'this': used in base member initializer list
+ #pragma warning(disable : 4365) // conversion from 'int' to 'const unsigned __int64', signed/unsigned mismatch
+ #pragma warning(disable : 4514) // unreferenced inline function has been removed
+ #pragma warning(disable : 4623) // default constructor was implicitly defined as deleted
+ #pragma warning(disable : 4625) // copy constructor was implicitly defined as deleted
+ #pragma warning(disable : 4626) // assignment operator was implicitly defined as deleted
+ #pragma warning(disable : 4710) // function not inlined
+ #pragma warning(disable : 4711) // selected for automatic inline expansion
+ #pragma warning(disable : 4820) // '6' bytes padding added after data member
+ #pragma warning(disable : 4868) // compiler may not enforce left-to-right evaluation order in braced initializer list
+ #pragma warning(disable : 5026) // move constructor was implicitly defined as deleted
+ #pragma warning(disable : 5027) // move assignment operator was implicitly defined as deleted
+ #pragma warning(disable : 5045) // Compiler will insert Spectre mitigation for memory load if /Qspectre switch specified
+#endif
+
+
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <limits>
+#include <new>
+
+#include "phmap_fwd_decl.h"
+#include "phmap_base.h"
+
+#if PHMAP_HAVE_STD_STRING_VIEW
+ #include <string_view>
+#endif
+
+// MSVC constructibility traits do not detect destructor properties and so our
+// implementations should not use them as a source-of-truth.
+#if defined(_MSC_VER) && !defined(__clang__) && !defined(__GNUC__)
+ #define PHMAP_META_INTERNAL_STD_CONSTRUCTION_TRAITS_DONT_CHECK_DESTRUCTION 1
+#endif
+
+namespace phmap {
+
+ // Defined and documented later on in this file.
+ template <typename T>
+ struct is_trivially_destructible;
+
+ // Defined and documented later on in this file.
+ template <typename T>
+ struct is_trivially_move_assignable;
+
+ namespace type_traits_internal {
+
+ // Silence MSVC warnings about the destructor being defined as deleted.
+#if defined(_MSC_VER) && !defined(__GNUC__)
+ #pragma warning(push)
+ #pragma warning(disable : 4624)
+#endif // defined(_MSC_VER) && !defined(__GNUC__)
+
+ template <class T>
+ union SingleMemberUnion {
+ T t;
+ };
+
+ // Restore the state of the destructor warning that was silenced above.
+#if defined(_MSC_VER) && !defined(__GNUC__)
+ #pragma warning(pop)
+#endif // defined(_MSC_VER) && !defined(__GNUC__)
+
+ template <class T>
+ struct IsTriviallyMoveConstructibleObject
+ : std::integral_constant<
+ bool, std::is_move_constructible<
+ type_traits_internal::SingleMemberUnion<T>>::value &&
+ phmap::is_trivially_destructible<T>::value> {};
+
+ template <class T>
+ struct IsTriviallyCopyConstructibleObject
+ : std::integral_constant<
+ bool, std::is_copy_constructible<
+ type_traits_internal::SingleMemberUnion<T>>::value &&
+ phmap::is_trivially_destructible<T>::value> {};
+
+ template <class T>
+ struct IsTriviallyMoveAssignableReference : std::false_type {};
+
+ template <class T>
+ struct IsTriviallyMoveAssignableReference<T&>
+ : phmap::is_trivially_move_assignable<T>::type {};
+
+ template <class T>
+ struct IsTriviallyMoveAssignableReference<T&&>
+ : phmap::is_trivially_move_assignable<T>::type {};
+
+ } // namespace type_traits_internal
+
+
+ template <typename... Ts>
+ using void_t = typename type_traits_internal::VoidTImpl<Ts...>::type;
+
+
+ template <typename T>
+ struct is_function
+ : std::integral_constant<
+ bool, !(std::is_reference<T>::value ||
+ std::is_const<typename std::add_const<T>::type>::value)> {};
+
+
+ namespace type_traits_internal {
+
+ template <typename T>
+ class is_trivially_copyable_impl {
+ using ExtentsRemoved = typename std::remove_all_extents<T>::type;
+ static constexpr bool kIsCopyOrMoveConstructible =
+ std::is_copy_constructible<ExtentsRemoved>::value ||
+ std::is_move_constructible<ExtentsRemoved>::value;
+ static constexpr bool kIsCopyOrMoveAssignable =
+ phmap::is_copy_assignable<ExtentsRemoved>::value ||
+ phmap::is_move_assignable<ExtentsRemoved>::value;
+
+ public:
+ static constexpr bool kValue =
+ (__has_trivial_copy(ExtentsRemoved) || !kIsCopyOrMoveConstructible) &&
+ (__has_trivial_assign(ExtentsRemoved) || !kIsCopyOrMoveAssignable) &&
+ (kIsCopyOrMoveConstructible || kIsCopyOrMoveAssignable) &&
+ is_trivially_destructible<ExtentsRemoved>::value &&
+ // We need to check for this explicitly because otherwise we'll say
+ // references are trivial copyable when compiled by MSVC.
+ !std::is_reference<ExtentsRemoved>::value;
+ };
+
+ template <typename T>
+ struct is_trivially_copyable
+ : std::integral_constant<
+ bool, type_traits_internal::is_trivially_copyable_impl<T>::kValue> {};
+ } // namespace type_traits_internal
+
+ namespace swap_internal {
+
+ // Necessary for the traits.
+ using std::swap;
+
+ // This declaration prevents global `swap` and `phmap::swap` overloads from being
+ // considered unless ADL picks them up.
+ void swap();
+
+ template <class T>
+ using IsSwappableImpl = decltype(swap(std::declval<T&>(), std::declval<T&>()));
+
+ // NOTE: This dance with the default template parameter is for MSVC.
+ template <class T,
+ class IsNoexcept = std::integral_constant<
+ bool, noexcept(swap(std::declval<T&>(), std::declval<T&>()))>>
+ using IsNothrowSwappableImpl = typename std::enable_if<IsNoexcept::value>::type;
+
+ template <class T>
+ struct IsSwappable
+ : phmap::type_traits_internal::is_detected<IsSwappableImpl, T> {};
+
+ template <class T>
+ struct IsNothrowSwappable
+ : phmap::type_traits_internal::is_detected<IsNothrowSwappableImpl, T> {};
+
+ template <class T, phmap::enable_if_t<IsSwappable<T>::value, int> = 0>
+ void Swap(T& lhs, T& rhs) noexcept(IsNothrowSwappable<T>::value) {
+ swap(lhs, rhs);
+ }
+
+ using StdSwapIsUnconstrained = IsSwappable<void()>;
+
+ } // namespace swap_internal
+
+ namespace type_traits_internal {
+
+ // Make the swap-related traits/function accessible from this namespace.
+ using swap_internal::IsNothrowSwappable;
+ using swap_internal::IsSwappable;
+ using swap_internal::Swap;
+ using swap_internal::StdSwapIsUnconstrained;
+
+ } // namespace type_traits_internal
+
+ namespace compare_internal {
+
+ using value_type = int8_t;
+
+ template <typename T>
+ struct Fail {
+ static_assert(sizeof(T) < 0, "Only literal `0` is allowed.");
+ };
+
+ template <typename NullPtrT = std::nullptr_t>
+ struct OnlyLiteralZero {
+ constexpr OnlyLiteralZero(NullPtrT) noexcept {} // NOLINT
+
+ template <
+ typename T,
+ typename = typename std::enable_if<
+ std::is_same<T, std::nullptr_t>::value ||
+ (std::is_integral<T>::value && !std::is_same<T, int>::value)>::type,
+ typename = typename Fail<T>::type>
+ OnlyLiteralZero(T); // NOLINT
+ };
+
+ enum class eq : value_type {
+ equal = 0,
+ equivalent = equal,
+ nonequal = 1,
+ nonequivalent = nonequal,
+ };
+
+ enum class ord : value_type { less = -1, greater = 1 };
+
+ enum class ncmp : value_type { unordered = -127 };
+
+#ifdef __cpp_inline_variables
+
+#d
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list