1 #include "dynamic_depth/planes.h"
2
3 #include "android-base/logging.h"
4 #include "dynamic_depth/const.h"
5
6 namespace dynamic_depth {
7
8 using ::dynamic_depth::xmpmeta::xml::Deserializer;
9 using ::dynamic_depth::xmpmeta::xml::Serializer;
10
11 // Private constructor.
12 Planes::Planes() = default;
13
GetNamespaces(std::unordered_map<string,string> * ns_name_href_map)14 void Planes::GetNamespaces(
15 std::unordered_map<string, string>* ns_name_href_map) {
16 if (ns_name_href_map == nullptr || plane_list_.empty()) {
17 LOG(ERROR) << "Namespace list is null or plane list is empty";
18 return;
19 }
20 for (const auto& plane : plane_list_) {
21 plane->GetNamespaces(ns_name_href_map);
22 }
23 }
24
FromPlaneArray(std::vector<std::unique_ptr<Plane>> * plane_list)25 std::unique_ptr<Planes> Planes::FromPlaneArray(
26 std::vector<std::unique_ptr<Plane>>* plane_list) {
27 if (plane_list == nullptr || plane_list->empty()) {
28 LOG(ERROR) << "Plane list is empty";
29 return nullptr;
30 }
31
32 for (const auto& plane : *plane_list) {
33 if (!plane) {
34 LOG(ERROR) << "plane_list cannot contain null elements";
35 return nullptr;
36 }
37 }
38
39 // Using `new` to access a non-public constructor.
40 std::unique_ptr<Planes> planes(new Planes()); // NOLINT
41 std::swap(*plane_list, planes->plane_list_);
42 return planes;
43 }
44
FromDeserializer(const Deserializer & parent_deserializer)45 std::unique_ptr<Planes> Planes::FromDeserializer(
46 const Deserializer& parent_deserializer) {
47 // Using `new` to access a non-public constructor.
48 std::unique_ptr<Planes> planes(new Planes()); // NOLINT
49 int i = 0;
50 std::unique_ptr<Deserializer> deserializer =
51 parent_deserializer.CreateDeserializerFromListElementAt(
52 DynamicDepthConst::Namespace(DynamicDepthConst::Planes()),
53 DynamicDepthConst::Planes(), 0);
54 while (deserializer) {
55 std::unique_ptr<Plane> plane = Plane::FromDeserializer(*deserializer);
56 if (plane == nullptr) {
57 LOG(ERROR) << "Unable to deserialize a plane";
58 return nullptr;
59 }
60
61 planes->plane_list_.push_back(std::move(plane));
62 i++;
63 deserializer = parent_deserializer.CreateDeserializerFromListElementAt(
64 DynamicDepthConst::Namespace(DynamicDepthConst::Planes()),
65 DynamicDepthConst::Planes(), i);
66 }
67
68 if (planes->plane_list_.empty()) {
69 return nullptr;
70 }
71 return planes;
72 }
73
GetPlaneCount() const74 int Planes::GetPlaneCount() const { return plane_list_.size(); }
75
GetPlaneAt(int i) const76 const Plane* Planes::GetPlaneAt(int i) const { return plane_list_[i].get(); }
77
Serialize(Serializer * serializer) const78 bool Planes::Serialize(Serializer* serializer) const {
79 if (plane_list_.empty()) {
80 LOG(ERROR) << "Plane list is empty";
81 return false;
82 }
83 std::unique_ptr<Serializer> planes_serializer =
84 serializer->CreateListSerializer(
85 DynamicDepthConst::Namespace(DynamicDepthConst::Planes()),
86 DynamicDepthConst::Planes());
87 if (planes_serializer == nullptr) {
88 // Error is logged in Serializer.
89 return false;
90 }
91 for (int i = 0; i < plane_list_.size(); i++) {
92 std::unique_ptr<Serializer> plane_serializer =
93 planes_serializer->CreateItemSerializer(
94 DynamicDepthConst::Namespace(DynamicDepthConst::Plane()),
95 DynamicDepthConst::Plane());
96 if (plane_serializer == nullptr) {
97 LOG(ERROR) << "Could not create a list item serializer for Plane";
98 return false;
99 }
100
101 if (plane_list_[i] == nullptr) {
102 LOG(ERROR) << "Plane " << i << " is null, could not serialize";
103 continue;
104 }
105
106 if (!plane_list_[i]->Serialize(plane_serializer.get())) {
107 LOG(ERROR) << "Could not serialize plane " << i;
108 continue;
109 }
110 }
111 return true;
112 }
113
114 } // namespace dynamic_depth
115