X-Git-Url: https://git.mdrn.pl/wl-app.git/blobdiff_plain/53b27422d140022594fc241cca91c3183be57bca..48b2fe9f7c2dc3d9aeaaa6dbfb27c7da4f3235ff:/iOS/Pods/Realm/include/sync/sync_config.hpp

diff --git a/iOS/Pods/Realm/include/sync/sync_config.hpp b/iOS/Pods/Realm/include/sync/sync_config.hpp
new file mode 100644
index 0000000..6fb4774
--- /dev/null
+++ b/iOS/Pods/Realm/include/sync/sync_config.hpp
@@ -0,0 +1,150 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// 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_OS_SYNC_CONFIG_HPP
+#define REALM_OS_SYNC_CONFIG_HPP
+
+#include "sync_user.hpp"
+#include "sync_manager.hpp"
+
+#include <realm/util/assert.hpp>
+#include <realm/sync/client.hpp>
+#include <realm/sync/protocol.hpp>
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <system_error>
+#include <unordered_map>
+
+#include <realm/sync/history.hpp>
+
+namespace realm {
+
+class SyncUser;
+class SyncSession;
+
+using ChangesetTransformer = sync::ClientHistory::ChangesetCooker;
+
+enum class SyncSessionStopPolicy;
+
+struct SyncConfig;
+using SyncBindSessionHandler = void(const std::string&,          // path on disk of the Realm file.
+                                    const SyncConfig&,           // the sync configuration object.
+                                    std::shared_ptr<SyncSession> // the session which should be bound.
+                                    );
+
+struct SyncError;
+using SyncSessionErrorHandler = void(std::shared_ptr<SyncSession>, SyncError);
+
+struct SyncError {
+    using ProtocolError = realm::sync::ProtocolError;
+
+    std::error_code error_code;
+    std::string message;
+    bool is_fatal;
+    std::unordered_map<std::string, std::string> user_info;
+    /// The sync server may send down an error that the client does not recognize,
+    /// whether because of a version mismatch or an oversight. It is still valuable
+    /// to expose these errors so that users can do something about them.
+    bool is_unrecognized_by_client = false;
+
+    SyncError(std::error_code error_code, std::string message, bool is_fatal)
+        : error_code(std::move(error_code))
+        , message(std::move(message))
+        , is_fatal(is_fatal)
+    {
+    }
+
+    static constexpr const char c_original_file_path_key[] = "ORIGINAL_FILE_PATH";
+    static constexpr const char c_recovery_file_path_key[] = "RECOVERY_FILE_PATH";
+
+    /// The error is a client error, which applies to the client and all its sessions.
+    bool is_client_error() const
+    {
+        return error_code.category() == realm::sync::client_error_category();
+    }
+
+    /// The error is a protocol error, which may either be connection-level or session-level.
+    bool is_connection_level_protocol_error() const
+    {
+        if (error_code.category() != realm::sync::protocol_error_category()) {
+            return false;
+        }
+        return !realm::sync::is_session_level_error(static_cast<ProtocolError>(error_code.value()));
+    }
+
+    /// The error is a connection-level protocol error.
+    bool is_session_level_protocol_error() const
+    {
+        if (error_code.category() != realm::sync::protocol_error_category()) {
+            return false;
+        }
+        return realm::sync::is_session_level_error(static_cast<ProtocolError>(error_code.value()));
+    }
+
+    /// The error indicates a client reset situation.
+    bool is_client_reset_requested() const
+    {
+        if (error_code.category() != realm::sync::protocol_error_category()) {
+            return false;
+        }
+        // Documented here: https://realm.io/docs/realm-object-server/#client-recovery-from-a-backup
+        return (error_code == ProtocolError::bad_server_file_ident
+                || error_code == ProtocolError::bad_client_file_ident
+                || error_code == ProtocolError::bad_server_version
+                || error_code == ProtocolError::diverging_histories);
+    }
+};
+
+struct SyncConfig {
+    std::shared_ptr<SyncUser> user;
+    // The URL of the Realm, or of the reference Realm if partial sync is being used.
+    // The URL that will be used when connecting to the object server is that returned by `realm_url()`,
+    // and will differ from `reference_realm_url` if partial sync is being used.
+    // Set this field, but read from `realm_url()`.
+    std::string reference_realm_url;
+    SyncSessionStopPolicy stop_policy = SyncSessionStopPolicy::AfterChangesUploaded;
+    std::function<SyncBindSessionHandler> bind_session_handler = nullptr;
+    std::function<SyncSessionErrorHandler> error_handler = nullptr;
+    std::shared_ptr<ChangesetTransformer> transformer = nullptr;
+    util::Optional<std::array<char, 64>> realm_encryption_key = none;
+    bool client_validate_ssl = true;
+    util::Optional<std::string> ssl_trust_certificate_path = none;
+    std::function<sync::Session::SSLVerifyCallback> ssl_verify_callback = nullptr;
+    bool is_partial = false;
+    util::Optional<std::string> custom_partial_sync_identifier = none;
+
+    bool validate_sync_history = true;
+
+    // The URL that will be used when connecting to the object server.
+    // This will differ from `reference_realm_url` when partial sync is being used.
+    std::string realm_url() const;
+
+    SyncConfig(std::shared_ptr<SyncUser> user, std::string reference_realm_url)
+    : user(std::move(user))
+    , reference_realm_url(std::move(reference_realm_url))
+    {
+        if (this->reference_realm_url.find("/__partial/") != npos)
+            throw std::invalid_argument("A Realm URL may not contain the reserved string \"/__partial/\".");
+    }
+};
+
+} // namespace realm
+
+#endif // REALM_OS_SYNC_CONFIG_HPP