1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifndef META_SRC_SERIALIZATION_SER_NODES_H
17 #define META_SRC_SERIALIZATION_SER_NODES_H
18 
19 #include <base/containers/unordered_map.h>
20 
21 #include <meta/base/ref_uri.h>
22 #include <meta/base/type_traits.h>
23 #include <meta/base/version.h>
24 #include <meta/ext/minimal_object.h>
25 #include <meta/ext/object_factory.h>
26 #include <meta/interface/intf_object_factory.h>
27 #include <meta/interface/serialization/intf_ser_node.h>
28 
29 #include "../base_object.h"
30 
31 META_BEGIN_NAMESPACE()
32 namespace Serialization {
33 
34 class NilNode : public Internal::BaseObjectFwd<NilNode, ClassId::NilNode, INilNode> {
35 public:
36     NilNode() = default;
37     void Apply(ISerNodeVisitor& v) override
38     {
39         v.Visit(*this);
40     }
41 };
42 
43 class MapNode : public Internal::BaseObjectFwd<MapNode, ClassId::MapNode, IMapNode> {
44 public:
45     MapNode() = default;
MapNode(BASE_NS::vector<NamedNode> elements)46     MapNode(BASE_NS::vector<NamedNode> elements) : elements(BASE_NS::move(elements)) {}
47 
48     BASE_NS::vector<NamedNode> GetMembers() const override
49     {
50         return elements;
51     }
52 
53     ISerNode::Ptr FindNode(BASE_NS::string_view name) const override
54     {
55         for (auto&& v : elements) {
56             if (name == v.name) {
57                 return v.node;
58             }
59         }
60         return nullptr;
61     }
62 
63     void AddNode(BASE_NS::string_view name, ISerNode::Ptr n) override
64     {
65         elements.push_back(NamedNode { BASE_NS::string(name), BASE_NS::move(n) });
66     }
67 
68     void Apply(ISerNodeVisitor& v) override
69     {
70         v.Visit(*this);
71     }
72 
73 public:
74     BASE_NS::vector<NamedNode> elements;
75 };
76 
77 class ArrayNode : public Internal::BaseObjectFwd<ArrayNode, ClassId::ArrayNode, IArrayNode> {
78 public:
79     ArrayNode() = default;
ArrayNode(BASE_NS::vector<ISerNode::Ptr> elements)80     ArrayNode(BASE_NS::vector<ISerNode::Ptr> elements) : elements(BASE_NS::move(elements)) {}
81 
82     BASE_NS::vector<ISerNode::Ptr> GetMembers() const override
83     {
84         return elements;
85     }
86 
87     void AddNode(const ISerNode::Ptr& node) override
88     {
89         elements.push_back(node);
90     }
91 
92     void Apply(ISerNodeVisitor& v) override
93     {
94         v.Visit(*this);
95     }
96 
97 public:
98     BASE_NS::vector<ISerNode::Ptr> elements;
99 };
100 
101 class ObjectNode : public Internal::BaseObjectFwd<ObjectNode, ClassId::ObjectNode, IObjectNode> {
102 public:
103     ObjectNode() = default;
ObjectNode(BASE_NS::string className, BASE_NS::string name, const ObjectId& oid, const InstanceId& iid, ISerNode::Ptr members)104     ObjectNode(BASE_NS::string className, BASE_NS::string name, const ObjectId& oid, const InstanceId& iid,
105         ISerNode::Ptr members)
106         : className(BASE_NS::move(className)), name(BASE_NS::move(name)), objectType(oid), instance(iid),
107           members(BASE_NS::move(members))
108     {}
109 
110     BASE_NS::string GetObjectClassName() const override
111     {
112         return className;
113     }
114     BASE_NS::string GetObjectName() const override
115     {
116         return name;
117     }
118     ObjectId GetObjectId() const override
119     {
120         return objectType;
121     }
122     InstanceId GetInstanceId() const override
123     {
124         return instance;
125     }
126     ISerNode::Ptr GetMembers() const override
127     {
128         return members;
129     }
130 
131     void SetObjectClassName(BASE_NS::string name) override
132     {
133         className = BASE_NS::move(name);
134     }
135     void SetObjectName(BASE_NS::string name) override
136     {
137         className = BASE_NS::move(name);
138     }
139     void SetObjectId(ObjectId id) override
140     {
141         objectType = id;
142     }
143     void SetInstanceId(InstanceId id) override
144     {
145         instance = id;
146     }
147     void SetMembers(ISerNode::Ptr n) override
148     {
149         members = BASE_NS::move(n);
150     }
151 
152     void Apply(ISerNodeVisitor& v) override
153     {
154         v.Visit(*this);
155     }
156 
157 public:
158     BASE_NS::string className;
159     BASE_NS::string name;
160     ObjectId objectType;
161     InstanceId instance;
162     ISerNode::Ptr members;
163 };
164 
165 class RootNode : public Internal::BaseObjectFwd<RootNode, ClassId::RootNode, IRootNode> {
166 public:
167     RootNode() = default;
RootNode(const Version& ver, ISerNode::Ptr obj)168     RootNode(const Version& ver, ISerNode::Ptr obj) : serializerVersion_(ver), object(BASE_NS::move(obj)) {}
169 
170     Version GetSerializerVersion() const override
171     {
172         return serializerVersion_;
173     }
174     ISerNode::Ptr GetObject() const override
175     {
176         return object;
177     }
178 
179     void Apply(ISerNodeVisitor& v) override
180     {
181         v.Visit(*this);
182     }
183 
184 public:
185     Version serializerVersion_ { 1, 0 };
186     ISerNode::Ptr object;
187 };
188 
189 template<typename Type, const META_NS::ClassInfo& ClassInfo>
190 class BuiltinValueNode
191     : public Internal::BaseObjectFwd<BuiltinValueNode<Type, ClassInfo>, ClassInfo, IBuiltinValueNode<Type>> {
192 public:
193     using InterfaceType = IBuiltinValueNode<Type>;
194 
195     BuiltinValueNode() = default;
BuiltinValueNode(const Type& v)196     BuiltinValueNode(const Type& v) : value(v) {}
197 
198     Type GetValue() const override
199     {
200         return value;
201     }
202 
203     void SetValue(const Type& v) override
204     {
205         value = v;
206     }
207 
208     void Apply(ISerNodeVisitor& v) override
209     {
210         v.Visit(*this);
211     }
212 
213 public:
214     Type value {};
215 };
216 
217 using BoolNode = BuiltinValueNode<bool, ClassId::BoolNode>;
218 using IntNode = BuiltinValueNode<int64_t, ClassId::IntNode>;
219 using UIntNode = BuiltinValueNode<uint64_t, ClassId::UIntNode>;
220 using DoubleNode = BuiltinValueNode<double, ClassId::DoubleNode>;
221 using StringNode = BuiltinValueNode<BASE_NS::string, ClassId::StringNode>;
222 using RefNode = BuiltinValueNode<RefUri, ClassId::RefNode>;
223 
224 template<typename Type, typename Node>
225 struct SupportedType {
226     using NodeType = Node;
227     constexpr const static TypeId ID = UidFromType<Type>();
228 
CreateNodeSerialization::SupportedType229     static ISerNode::Ptr CreateNode(const IAny& any)
230     {
231         return ISerNode::Ptr(new NodeType(GetValue<Type>(any)));
232     }
233 
ExtractValueSerialization::SupportedType234     static AnyReturnValue ExtractValue(const ISerNode::ConstPtr& n, IAny& any)
235     {
236         Type v {};
237         if (auto node = interface_cast<typename NodeType::InterfaceType>(n)) {
238             v = static_cast<Type>(node->GetValue());
239         } else {
240             if constexpr (BASE_NS::is_same_v<NodeType, IntNode> || BASE_NS::is_same_v<NodeType, DoubleNode>) {
241                 if (auto node = interface_cast<UIntNode::InterfaceType>(n)) {
242                     v = static_cast<Type>(node->GetValue());
243                 } else if (auto node = interface_cast<IntNode::InterfaceType>(n)) {
244                     v = static_cast<Type>(node->GetValue());
245                 }
246             }
247         }
248         return any.SetValue(v);
249     }
250 };
251 
252 // clang-format off
253 using SupportedBuiltins = TypeList<
254     SupportedType<bool, BoolNode>,
255     SupportedType<double, DoubleNode>,
256     SupportedType<uint8_t, UIntNode>,
257     SupportedType<uint16_t, UIntNode>,
258     SupportedType<uint32_t, UIntNode>,
259     SupportedType<uint64_t, UIntNode>,
260     SupportedType<int8_t, IntNode>,
261     SupportedType<int16_t, IntNode>,
262     SupportedType<int32_t, IntNode>,
263     SupportedType<int64_t, IntNode>,
264     SupportedType<BASE_NS::string, StringNode>,
265     SupportedType<RefUri, RefNode>
266     >;
267 // clang-format on
268 
269 } // namespace Serialization
270 META_END_NAMESPACE()
271 
272 #endif
273