Port Firestore Document to C++

Firestore/core/src/firebase/firestore/model/CMakeLists.txt

@@ -18,16 +18,22 @@ cc_library(
     base_path.h
     database_id.cc
     database_id.h
+    document.cc
+    document.h
     document_key.cc
     document_key.h
     field_path.cc
     field_path.h
     field_value.cc
     field_value.h
-    snapshot_version.cc
-    snapshot_version.h
+    maybe_document.cc
+    maybe_document.h
+    no_document.cc
+    no_document.h
     resource_path.cc
     resource_path.h
+    snapshot_version.cc
+    snapshot_version.h
     timestamp.cc
     timestamp.h
   DEPENDS

Firestore/core/src/firebase/firestore/model/document.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2018 Google
+ *
+ * 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 "Firestore/core/src/firebase/firestore/model/document.h"
+
+#include <utility>
+
+#include "Firestore/core/src/firebase/firestore/util/firebase_assert.h"
+
+namespace firebase {
+namespace firestore {
+namespace model {
+
+Document::Document(const FieldValue& data,
+                   const DocumentKey& key,
+                   const SnapshotVersion& version,
+                   bool has_local_mutations)
+    : MaybeDocument(key, version),
+      data_(data),
+      has_local_mutations_(has_local_mutations) {
+  set_type(Type::Document);
+  FIREBASE_ASSERT(FieldValue::Type::Object == data.type());
+}
+
+Document::Document(FieldValue&& data,
+                   const DocumentKey& key,
+                   const SnapshotVersion& version,
+                   bool has_local_mutations)
+    : MaybeDocument(key, version),
+      data_(std::move(data)),
+      has_local_mutations_(has_local_mutations) {
+  set_type(Type::Document);
+  FIREBASE_ASSERT(FieldValue::Type::Object == data.type());
+}
+
+}  // namespace model
+}  // namespace firestore
+}  // namespace firebase

Firestore/core/src/firebase/firestore/model/document.h

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2018 Google
+ *
+ * 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 FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_MODEL_DOCUMENT_H_
+#define FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_MODEL_DOCUMENT_H_
+
+#include "Firestore/core/src/firebase/firestore/model/field_value.h"
+#include "Firestore/core/src/firebase/firestore/model/maybe_document.h"
+
+namespace firebase {
+namespace firestore {
+namespace model {
+
+/**
+ * Represents a document in Firestore with a key, version, data and whether the
+ * data has local mutations applied to it.
+ */
+class Document : public MaybeDocument {
+ public:
+  Document(const FieldValue& data,
+           const DocumentKey& key,
+           const SnapshotVersion& version,
+           bool has_local_mutations);
+
+  Document(FieldValue&& data,
+           const DocumentKey& key,
+           const SnapshotVersion& version,
+           bool has_local_mutations);
+
+  const FieldValue& data() const {
+    return data_;
+  }
+
+  bool has_local_mutations() const {
+    return has_local_mutations_;
+  }
+
+ private:
+  FieldValue data_;  // This is of type Object.
+  bool has_local_mutations_;
+};
+
+/** Compares against another Document. */
+inline bool operator==(const Document& lhs, const Document& rhs) {
+  return lhs.version() == rhs.version() && lhs.key() == rhs.key() &&
+         lhs.has_local_mutations() == rhs.has_local_mutations() &&
+         lhs.data() == rhs.data();
+}
+
+inline bool operator!=(const Document& lhs, const Document& rhs) {
+  return !(lhs == rhs);
+}
+
+}  // namespace model
+}  // namespace firestore
+}  // namespace firebase
+
+#endif  // FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_MODEL_DOCUMENT_H_

Firestore/core/src/firebase/firestore/model/maybe_document.cc

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2018 Google
+ *
+ * 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 "Firestore/core/src/firebase/firestore/model/maybe_document.h"
+
+namespace firebase {
+namespace firestore {
+namespace model {
+
+MaybeDocument::MaybeDocument(const DocumentKey& key,
+                             const SnapshotVersion& version)
+    : type_(Type::Unknown), key_(key), version_(version) {
+}
+
+}  // namespace model
+}  // namespace firestore
+}  // namespace firebase

Firestore/core/src/firebase/firestore/model/maybe_document.h

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2018 Google
+ *
+ * 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 FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_MODEL_MAYBE_DOCUMENT_H_
+#define FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_MODEL_MAYBE_DOCUMENT_H_
+
+#include "Firestore/core/src/firebase/firestore/model/document_key.h"
+#include "Firestore/core/src/firebase/firestore/model/snapshot_version.h"
+
+namespace firebase {
+namespace firestore {
+namespace model {
+
+/**
+ * The result of a lookup for a given path may be an existing document or a
+ * tombstone that marks the path deleted.
+ */
+class MaybeDocument {
+ public:
+  enum class Type {
+    Unknown,
+    Document,
+    NoDocument,
+  };
+
+  MaybeDocument(const DocumentKey& key, const SnapshotVersion& version);
+
+  Type type() const {
+    return type_;
+  }
+
+  const DocumentKey& key() const {
+    return key_;
+  }
+
+  const SnapshotVersion& version() const {
+    return version_;
+  }
+
+ protected:
+  // Only allow subclass to set their types.
+  void set_type(Type type) {
+    type_ = type;
+  }
+
+ private:
+  Type type_;
+  DocumentKey key_;
+  SnapshotVersion version_;
+};
+
+/** Compares against another MaybeDocument. */
+inline bool operator<(const MaybeDocument& lhs, const MaybeDocument& rhs) {
+  return lhs.key() < rhs.key();
+}
+
+inline bool operator>(const MaybeDocument& lhs, const MaybeDocument& rhs) {
+  return lhs.key() > rhs.key();
+}
+
+inline bool operator>=(const MaybeDocument& lhs, const MaybeDocument& rhs) {
+  return lhs.key() >= rhs.key();
+}
+
+inline bool operator<=(const MaybeDocument& lhs, const MaybeDocument& rhs) {
+  return lhs.key() <= rhs.key();
+}
+
+inline bool operator!=(const MaybeDocument& lhs, const MaybeDocument& rhs) {
+  return lhs.key() != rhs.key() || lhs.type() != rhs.type();
+}
+
+inline bool operator==(const MaybeDocument& lhs, const MaybeDocument& rhs) {
+  return lhs.key() == rhs.key() && lhs.type() == rhs.type();
+}
+
+}  // namespace model
+}  // namespace firestore
+}  // namespace firebase
+
+#endif  // FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_MODEL_MAYBE_DOCUMENT_H_

Firestore/core/src/firebase/firestore/model/no_document.cc

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2018 Google
+ *
+ * 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 "Firestore/core/src/firebase/firestore/model/no_document.h"
+
+namespace firebase {
+namespace firestore {
+namespace model {
+
+NoDocument::NoDocument(const DocumentKey& key, const SnapshotVersion& version)
+    : MaybeDocument(key, version) {
+  set_type(Type::NoDocument);
+}
+
+}  // namespace model
+}  // namespace firestore
+}  // namespace firebase

Firestore/core/src/firebase/firestore/model/no_document.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2018 Google
+ *
+ * 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 FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_MODEL_NO_DOCUMENT_H_
+#define FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_MODEL_NO_DOCUMENT_H_
+
+#include "Firestore/core/src/firebase/firestore/model/maybe_document.h"
+
+namespace firebase {
+namespace firestore {
+namespace model {
+
+/** Represents that no documents exists for the key at the given version. */
+class NoDocument : public MaybeDocument {
+ public:
+  NoDocument(const DocumentKey& key, const SnapshotVersion& version);
+};
+
+}  // namespace model
+}  // namespace firestore
+}  // namespace firebase
+
+#endif  // FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_MODEL_NO_DOCUMENT_H_

Firestore/core/test/firebase/firestore/model/CMakeLists.txt

@@ -17,11 +17,14 @@ cc_test(
   SOURCES
     database_id_test.cc
     document_key_test.cc
+    document_test.cc
     field_path_test.cc
     field_value_test.cc
+    maybe_document_test.cc
+    no_document_test.cc
+    resource_path_test.cc
     snapshot_version_test.cc
     timestamp_test.cc
-    resource_path_test.cc
   DEPENDS
     firebase_firestore_model
 )