xref: /base/update/updater/utils/json/json_node.h (revision fb299fa2) 
1/*
2 * Copyright (c) 2022 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 JSON_NODE_H
17#define JSON_NODE_H
18
19#include <filesystem>
20#include <list>
21#include <memory>
22#include <optional>
23#include <string>
24#include <type_traits>
25#include <unordered_map>
26#include <variant>
27#include <vector>
28
29#include "cJSON.h"
30#include "log/log.h"
31#include "macros_updater.h"
32#include "traits_util.h"
33
34namespace Updater {
35class JsonNode;
36
37enum class NodeType { OBJECT, INT, STRING, ARRAY, BOOL, NUL, UNKNOWN };
38
39using NodeMap = std::unordered_map<std::string, std::unique_ptr<JsonNode>>;
40using NodeVec = std::vector<std::unique_ptr<JsonNode>>;
41using cJSONPtr = std::unique_ptr<cJSON, decltype(&cJSON_Delete)>;
42template<typename...T>
43using optionalVariant = std::variant<std::optional<T> ...>;
44
45namespace Fs = std::filesystem;
46class JsonNode {
47    DISALLOW_COPY_MOVE(JsonNode);
48public:
49    JsonNode();
50    explicit JsonNode(const Fs::path &path);
51    explicit JsonNode(const std::string &str, bool needDelete = true);
52    explicit JsonNode(const cJSON *root, bool needDelete = true);
53    ~JsonNode();
54
55    const JsonNode &operator[](int idx) const;
56    const JsonNode &operator[](const std::string &key) const;
57    JsonNode &operator[](int idx);
58    JsonNode &operator[](const std::string &key);
59
60    template<typename T>
61    std::optional<T> As() const
62    {
63        if (auto optPtr = std::get_if<std::optional<Detail::StandardType<T>>>(&innerObj_); optPtr) {
64            return *optPtr;
65        }
66        return std::nullopt;
67    }
68
69    template<typename T>
70    bool operator==(T rhs) const
71    {
72        if (auto optPtr = std::get_if<std::optional<Detail::StandardType<T>>>(&innerObj_); optPtr) {
73            return *optPtr == rhs;
74        }
75        return false;
76    }
77
78    int Size() const
79    {
80        return size_;
81    }
82    NodeType Type() const
83    {
84        return type_;
85    }
86    std::optional<std::string> Key() const
87    {
88        return key_;
89    }
90    std::list<std::reference_wrapper<JsonNode>>::const_iterator begin() const;
91    std::list<std::reference_wrapper<JsonNode>>::const_iterator end() const;
92    template<typename T>
93    void operator=(T &&rhs)
94    {
95        static_assert(Detail::G_IS_BASE_TYPE<Detail::RemoveCvRef<T>>, "only allow change int, string, bool value");
96        if (innerObj_.valueless_by_exception()) {
97            innerObj_ = Detail::OptStandardType<T>(rhs);
98        }
99        if (auto optPtr = std::get_if<Detail::OptStandardType<T>>(&innerObj_); optPtr) {
100            *optPtr = Detail::OptStandardType<T>(rhs);
101        } else {
102            LOG(ERROR) << "assign json node failed, key is " << key_.value_or("null") << ", type is "
103                << static_cast<int>(type_) << ", rhs is " << rhs;
104        }
105    }
106private:
107    void Parse(const cJSON *root);
108    void Init(const cJSON *root, bool needDelete);
109    int size_ {1};
110    NodeType type_ {NodeType::UNKNOWN};         /* json node type */
111    std::optional<std::string> key_ {std::nullopt}; /* key for object items */
112    optionalVariant<bool, int, std::string, NodeVec, NodeMap> innerObj_ {};
113    std::list<std::reference_wrapper<JsonNode>> innerNodesList_ {};
114};
115
116inline JsonNode &GetInvalidNode()
117{
118    static JsonNode emptyNode;  // used for invalid json node
119    return emptyNode;
120}
121
122template<typename T>
123inline JsonNode &GetNodeByIdx(T &innerObj, int size, int idx)
124{
125    auto optVec = std::get_if<std::optional<NodeVec>>(&innerObj);
126    if (optVec == nullptr || *optVec == std::nullopt) {
127        return GetInvalidNode(); // type not matched
128    }
129    auto &nodeVec = **optVec;
130    if (idx < 0 || idx >= size) {
131        return GetInvalidNode();
132    }
133    return *nodeVec[idx];
134}
135
136template<typename T>
137inline JsonNode &GetNodeByKey(T &innerObj, const std::string &key)
138{
139    auto optMap = std::get_if<std::optional<NodeMap>>(&innerObj);
140    if (optMap == nullptr || *optMap == std::nullopt) {
141        return GetInvalidNode(); // type not matched
142    }
143    auto &nodeMap = **optMap;
144    if (auto it = nodeMap.find(key); it != nodeMap.end()) {
145        return *(it->second);
146    }
147    return GetInvalidNode();
148}
149}
150#endif // NODE_H
151