1 /*
2  * Copyright (c) 2021-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 #include "stoperator.h"
16 #include <cstring>
17 
18 namespace STtools {
19 using std::string;
20 
PushOperatorInVector(std::vector<string> & vectorOperator,StOperator & ParentOperator)21 void PushOperatorInVector(std::vector<string> &vectorOperator, StOperator &ParentOperator)
22 {
23     vectorOperator.emplace_back(std::to_string(ParentOperator.GetChildOperator().size()));
24     vectorOperator.emplace_back(ParentOperator.GetAbilityType());
25     vectorOperator.emplace_back(ParentOperator.GetBundleName());
26     vectorOperator.emplace_back(ParentOperator.GetAbilityName());
27     vectorOperator.emplace_back(ParentOperator.GetOperatorName());
28     vectorOperator.emplace_back(ParentOperator.GetMessage());
29     for (auto child : ParentOperator.GetChildOperator()) {
30         PushOperatorInVector(vectorOperator, *child);
31     }
32 }
33 
SerializationStOperatorToVector(StOperator & ParentOperator)34 std::vector<string> SerializationStOperatorToVector(StOperator &ParentOperator)
35 {
36     std::vector<string> vectorOperator;
37     PushOperatorInVector(vectorOperator, ParentOperator);
38     return vectorOperator;
39 }
40 
PullOperatorFromVector(StOperator & ParentOperator,std::vector<string> & vectorOperator)41 void PullOperatorFromVector(StOperator &ParentOperator, std::vector<string> &vectorOperator)
42 {
43     int childnum = std::stoi(vectorOperator.front());
44     vectorOperator.erase(vectorOperator.begin());
45     string abilityType = vectorOperator.front();
46     vectorOperator.erase(vectorOperator.begin());
47     string bundleName = vectorOperator.front();
48     vectorOperator.erase(vectorOperator.begin());
49     string abilityName = vectorOperator.front();
50     vectorOperator.erase(vectorOperator.begin());
51     string operatorName = vectorOperator.front();
52     vectorOperator.erase(vectorOperator.begin());
53     string message = vectorOperator.front();
54     vectorOperator.erase(vectorOperator.begin());
55     ParentOperator.SetAbilityType(abilityType)
56         .SetBundleName(bundleName)
57         .SetAbilityName(abilityName)
58         .SetOperatorName(operatorName)
59         .SetMessage(message);
60     for (int i = 0; i < childnum; i++) {
61         auto child = std::make_shared<StOperator>();
62         ParentOperator.AddChildOperator(child);
63         PullOperatorFromVector(*(child.get()), vectorOperator);
64     }
65 }
66 
DeserializationStOperatorFromVector(StOperator & ParentOperator,std::vector<string> & vectorOperator)67 void DeserializationStOperatorFromVector(StOperator &ParentOperator, std::vector<string> &vectorOperator)
68 {
69     PullOperatorFromVector(ParentOperator, vectorOperator);
70 }
71 
72 int StOperator::countChild = 0;
73 
StOperator()74 StOperator::StOperator()
75     : g_parentOperator(nullptr), g_abilityType("0"),
76     g_bundleName(""), g_abilityName(""), g_operatorName(""), g_message("")
77 {
78     g_childOperator.clear();
79     StOperator::countChild++;
80 }
81 
StOperator(const string & type,const string & bundle,const string & ability,const string & operatorName,const string & message)82 StOperator::StOperator(
83     const string &type, const string &bundle, const string &ability, const string &operatorName, const string &message)
84     : g_parentOperator(nullptr),
85       g_abilityType(type),
86       g_bundleName(bundle),
87       g_abilityName(ability),
88       g_operatorName(operatorName),
89       g_message("")
90 {
91     g_childOperator.clear();
92     StOperator::countChild++;
93 }
94 
~StOperator()95 StOperator::~StOperator()
96 {
97     g_childOperator.clear();
98     StOperator::countChild--;
99 }
100 
GetCountChild()101 int StOperator::GetCountChild()
102 {
103     return StOperator::countChild;
104 }
105 
GetAbilityType()106 string StOperator::GetAbilityType()
107 {
108     return g_abilityType;
109 }
110 
SetAbilityType(const string & type)111 StOperator &StOperator::SetAbilityType(const string &type)
112 {
113     g_abilityType = type;
114     return *this;
115 }
116 
GetBundleName()117 string StOperator::GetBundleName()
118 {
119     return g_bundleName;
120 }
121 
SetBundleName(const string & bundleName)122 StOperator &StOperator::SetBundleName(const string &bundleName)
123 {
124     g_bundleName = bundleName;
125     return *this;
126 }
127 
GetAbilityName()128 string StOperator::GetAbilityName()
129 {
130     return g_abilityName;
131 }
132 
SetAbilityName(const string & abilityName)133 StOperator &StOperator::SetAbilityName(const string &abilityName)
134 {
135     g_abilityName = abilityName;
136     return *this;
137 }
138 
GetOperatorName()139 string StOperator::GetOperatorName()
140 {
141     return g_operatorName;
142 }
143 
SetOperatorName(const string & operatorName)144 StOperator &StOperator::SetOperatorName(const string &operatorName)
145 {
146     g_operatorName = operatorName;
147     return *this;
148 }
149 
GetMessage()150 string StOperator::GetMessage()
151 {
152     return g_message;
153 }
154 
SetMessage(const string & message)155 StOperator &StOperator::SetMessage(const string &message)
156 {
157     g_message = message;
158     return *this;
159 }
160 
AddChildOperator(std::shared_ptr<StOperator> childOperator)161 StOperator &StOperator::AddChildOperator(std::shared_ptr<StOperator> childOperator)
162 {
163     if (childOperator == nullptr) {
164         return *this;
165     }
166     childOperator->g_parentOperator = std::make_shared<StOperator>(*this);
167     g_childOperator.emplace_back(childOperator);
168     return *this;
169 }
170 
GetChildOperator()171 std::vector<std::shared_ptr<StOperator>> StOperator::GetChildOperator()
172 {
173     return g_childOperator;
174 }
175 
PopChildOperator()176 std::vector<std::shared_ptr<StOperator>> StOperator::PopChildOperator()
177 {
178     std::vector<std::shared_ptr<StOperator>> popChildOperator = g_childOperator;
179     for (auto child : popChildOperator) {
180         child->g_parentOperator = nullptr;
181     }
182     g_childOperator.clear();
183     return popChildOperator;
184 }
185 }  // namespace STtools