X-Git-Url: https://git.mdrn.pl/wl-app.git/blobdiff_plain/53b27422d140022594fc241cca91c3183be57bca..48b2fe9f7c2dc3d9aeaaa6dbfb27c7da4f3235ff:/iOS/Pods/Realm/include/core/realm/impl/simulated_failure.hpp?ds=sidebyside

diff --git a/iOS/Pods/Realm/include/core/realm/impl/simulated_failure.hpp b/iOS/Pods/Realm/include/core/realm/impl/simulated_failure.hpp
new file mode 100644
index 0000000..4958151
--- /dev/null
+++ b/iOS/Pods/Realm/include/core/realm/impl/simulated_failure.hpp
@@ -0,0 +1,228 @@
+/*************************************************************************
+ *
+ * Copyright 2016 Realm 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.
+ *
+ **************************************************************************/
+
+#ifndef REALM_IMPL_SIMULATED_FAILURE_HPP
+#define REALM_IMPL_SIMULATED_FAILURE_HPP
+
+#include <cstdint>
+#include <system_error>
+
+#include <realm/util/features.h>
+
+#ifdef REALM_DEBUG
+#define REALM_ENABLE_SIMULATED_FAILURE
+#endif
+
+namespace realm {
+namespace _impl {
+
+class SimulatedFailure : public std::system_error {
+public:
+    enum FailureType {
+        generic,
+        slab_alloc__reset_free_space_tracking,
+        slab_alloc__remap,
+        shared_group__grow_reader_mapping,
+        sync_client__read_head,
+        sync_server__read_head,
+        _num_failure_types
+    };
+
+    class OneShotPrimeGuard;
+    class RandomPrimeGuard;
+
+    /// Prime the specified failure type on the calling thread for triggering
+    /// once.
+    static void prime_one_shot(FailureType);
+
+    /// Prime the specified failure type on the calling thread for triggering
+    /// randomly \a n out of \a m times.
+    static void prime_random(FailureType, int n, int m, uint_fast64_t seed = 0);
+
+    /// Unprime the specified failure type on the calling thread.
+    static void unprime(FailureType) noexcept;
+
+    /// Returns true according to the mode of priming of the specified failure
+    /// type on the calling thread, but only if REALM_ENABLE_SIMULATED_FAILURE
+    /// was defined during compilation. If REALM_ENABLE_SIMULATED_FAILURE was
+    /// not defined, this function always return false.
+    static bool check_trigger(FailureType) noexcept;
+
+    /// The specified error code is set to `make_error_code(failure_type)` if
+    /// check_trigger() returns true. Otherwise it is set to
+    /// `std::error_code()`. Returns a copy of the updated error code.
+    static std::error_code trigger(FailureType failure_type, std::error_code&) noexcept;
+
+    /// Throws SimulatedFailure if check_trigger() returns true. The exception
+    /// will be constructed with an error code equal to
+    /// `make_error_code(failure_type)`.
+    static void trigger(FailureType failure_type);
+
+    /// Returns true when, and only when REALM_ENABLE_SIMULATED_FAILURE was
+    /// defined during compilation.
+    static constexpr bool is_enabled();
+
+    SimulatedFailure(std::error_code);
+
+private:
+#ifdef REALM_ENABLE_SIMULATED_FAILURE
+    static void do_prime_one_shot(FailureType);
+    static void do_prime_random(FailureType, int n, int m, uint_fast64_t seed);
+    static void do_unprime(FailureType) noexcept;
+    static bool do_check_trigger(FailureType) noexcept;
+#endif
+};
+
+std::error_code make_error_code(SimulatedFailure::FailureType) noexcept;
+    
+class SimulatedFailure::OneShotPrimeGuard {
+public:
+    OneShotPrimeGuard(FailureType);
+    ~OneShotPrimeGuard() noexcept;
+
+private:
+    const FailureType m_type;
+};
+
+
+class SimulatedFailure::RandomPrimeGuard {
+public:
+    RandomPrimeGuard(FailureType, int n, int m, uint_fast64_t seed = 0);
+    ~RandomPrimeGuard() noexcept;
+
+private:
+    const FailureType m_type;
+};
+
+std::error_code make_error_code(SimulatedFailure::FailureType) noexcept;
+
+} // namespace _impl
+} // namespace realm
+
+namespace std {
+
+template<> struct is_error_code_enum<realm::_impl::SimulatedFailure::FailureType> {
+    static const bool value = true;
+};
+
+} // namespace std
+
+namespace realm {
+namespace _impl {
+
+
+// Implementation
+
+inline void SimulatedFailure::prime_one_shot(FailureType failure_type)
+{
+#ifdef REALM_ENABLE_SIMULATED_FAILURE
+    do_prime_one_shot(failure_type);
+#else
+    static_cast<void>(failure_type);
+#endif
+}
+
+inline void SimulatedFailure::prime_random(FailureType failure_type, int n, int m, uint_fast64_t seed)
+{
+#ifdef REALM_ENABLE_SIMULATED_FAILURE
+    do_prime_random(failure_type, n, m, seed);
+#else
+    static_cast<void>(failure_type);
+    static_cast<void>(n);
+    static_cast<void>(m);
+    static_cast<void>(seed);
+#endif
+}
+
+inline void SimulatedFailure::unprime(FailureType failure_type) noexcept
+{
+#ifdef REALM_ENABLE_SIMULATED_FAILURE
+    do_unprime(failure_type);
+#else
+    static_cast<void>(failure_type);
+#endif
+}
+
+inline bool SimulatedFailure::check_trigger(FailureType failure_type) noexcept
+{
+#ifdef REALM_ENABLE_SIMULATED_FAILURE
+    return do_check_trigger(failure_type);
+#else
+    static_cast<void>(failure_type);
+    return false;
+#endif
+}
+
+inline std::error_code SimulatedFailure::trigger(FailureType failure_type, std::error_code& ec) noexcept
+{
+    if (check_trigger(failure_type)) {
+        ec = make_error_code(failure_type);
+    }
+    else {
+        ec = std::error_code();
+    }
+    return ec;
+}
+
+inline void SimulatedFailure::trigger(FailureType failure_type)
+{
+    if (check_trigger(failure_type))
+        throw SimulatedFailure(make_error_code(failure_type));
+}
+
+inline constexpr bool SimulatedFailure::is_enabled()
+{
+#ifdef REALM_ENABLE_SIMULATED_FAILURE
+    return true;
+#else
+    return false;
+#endif
+}
+
+inline SimulatedFailure::SimulatedFailure(std::error_code ec)
+    : std::system_error(ec)
+{
+}
+
+inline SimulatedFailure::OneShotPrimeGuard::OneShotPrimeGuard(FailureType failure_type)
+    : m_type(failure_type)
+{
+    prime_one_shot(m_type);
+}
+
+inline SimulatedFailure::OneShotPrimeGuard::~OneShotPrimeGuard() noexcept
+{
+    unprime(m_type);
+}
+
+inline SimulatedFailure::RandomPrimeGuard::RandomPrimeGuard(FailureType failure_type, int n, int m,
+                                                            uint_fast64_t seed)
+    : m_type(failure_type)
+{
+    prime_random(m_type, n, m, seed);
+}
+
+inline SimulatedFailure::RandomPrimeGuard::~RandomPrimeGuard() noexcept
+{
+    unprime(m_type);
+}
+
+} // namespace _impl
+} // namespace realm
+
+#endif // REALM_IMPL_SIMULATED_FAILURE_HPP