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#include "udmf_conversion.h"
17#include "unified_data.h"
18#include "application_defined_record.h"
19#include "audio.h"
20#include "file.h"
21#include "folder.h"
22#include "html.h"
23#include "image.h"
24#include "link.h"
25#include "plain_text.h"
26#include "system_defined_appitem.h"
27#include "system_defined_form.h"
28#include "system_defined_pixelmap.h"
29#include "system_defined_record.h"
30#include "text.h"
31#include "unified_record.h"
32#include "video.h"
33#include <memory>
34#include <utility>
35
36namespace OHOS::UDMF {
37
38void UdmfConversion::SetValueWhenNotUds(std::shared_ptr<UnifiedRecord> record)
39{
40    if (!std::holds_alternative<std::shared_ptr<Object>>(record->GetValue())) {
41        return;
42    }
43    auto object = std::get<std::shared_ptr<Object>>(record->GetValue());
44    auto it = object->value_.find(VALUE_TYPE);
45    if (it == object->value_.end()) {
46        return;
47    }
48    if (std::holds_alternative<std::shared_ptr<Object>>(it->second)) {
49        return;
50    }
51    record->SetValue(it->second);
52}
53
54void UdmfConversion::ConvertRecordToSubclass(std::shared_ptr<UnifiedRecord> &record)
55{
56    auto type = record->GetType();
57    auto value = record->GetOriginValue();
58    auto uid = record->GetUid();
59    switch (type) {
60        case UDType::TEXT: {
61            record = std::make_shared<Text>(type, value);
62            break;
63        }
64        case UDType::PLAIN_TEXT: {
65            record = std::make_shared<PlainText>(type, value);
66            break;
67        }
68        case UDType::HTML: {
69            record = std::make_shared<Html>(type, value);
70            break;
71        }
72        case UDType::HYPERLINK: {
73            record = std::make_shared<Link>(type, value);
74            break;
75        }
76        case UDType::FILE: {
77            record = std::make_shared<File>(type, value);
78            break;
79        }
80        case UDType::IMAGE: {
81            record = std::make_shared<Image>(type, value);
82            break;
83        }
84        case UDType::VIDEO: {
85            record = std::make_shared<Video>(type, value);
86            break;
87        }
88        case UDType::AUDIO: {
89            record = std::make_shared<Audio>(type, value);
90            break;
91        }
92        case UDType::FOLDER: {
93            record = std::make_shared<Folder>(type, value);
94            break;
95        }
96        case UDType::SYSTEM_DEFINED_RECORD: {
97            record = std::make_shared<SystemDefinedRecord>(type, value);
98            break;
99        }
100        case UDType::SYSTEM_DEFINED_FORM: {
101            record = std::make_shared<SystemDefinedForm>(type, value);
102            break;
103        }
104        case UDType::SYSTEM_DEFINED_APP_ITEM: {
105            record = std::make_shared<SystemDefinedAppItem>(type, value);
106            break;
107        }
108        case UDType::SYSTEM_DEFINED_PIXEL_MAP: {
109            record = std::make_shared<SystemDefinedPixelMap>(type, value);
110            break;
111        }
112        case UDType::APPLICATION_DEFINED_RECORD: {
113            record = std::make_shared<ApplicationDefinedRecord>(type, value);
114            break;
115        }
116        default: {
117            record = std::make_shared<UnifiedRecord>(type, value);
118        }
119    }
120    record->SetUid(uid);
121    SetValueWhenNotUds(record);
122}
123
124void UdmfConversion::ConvertRecordToSubclass(UnifiedData &data)
125{
126    std::vector<std::shared_ptr<UnifiedRecord>> records;
127    for (auto &record : data.GetRecords()) {
128        ConvertRecordToSubclass(record);
129        records.push_back(std::move(record));
130    }
131    data.SetRecords(records);
132}
133
134void UdmfConversion::ConvertRecordToSubclass(std::vector<UnifiedData> &datas)
135{
136    for (auto &data : datas) {
137        ConvertRecordToSubclass(data);
138    }
139}
140
141void UdmfConversion::InitValueObject(UnifiedData &data)
142{
143    for (auto &record : data.GetRecords()) {
144        record->InitObject();
145    }
146}
147
148void UdmfConversion::InitValueObject(std::vector<UnifiedData> &datas)
149{
150    for (auto &data : datas) {
151        InitValueObject(data);
152    }
153}
154}
155