1 //
2 // Copyright (C) 2012 The Android Open Source Project
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16
17 #include "shill/property_store.h"
18
19 #include <map>
20 #include <string>
21 #include <vector>
22
23 #include <base/stl_util.h>
24 #include <dbus/object_path.h>
25
26 #include "shill/error.h"
27 #include "shill/logging.h"
28 #include "shill/property_accessor.h"
29
30 using std::map;
31 using std::string;
32 using std::vector;
33
34 namespace shill {
35
36 namespace Logging {
37 static auto kModuleLogScope = ScopeLogger::kProperty;
ObjectID(const PropertyStore * p)38 static string ObjectID(const PropertyStore* p) { return "(property_store)"; }
39 }
40
PropertyStore()41 PropertyStore::PropertyStore() {}
42
PropertyStore(PropertyChangeCallback on_property_changed)43 PropertyStore::PropertyStore(PropertyChangeCallback on_property_changed) :
44 property_changed_callback_(on_property_changed) {}
45
~PropertyStore()46 PropertyStore::~PropertyStore() {}
47
Contains(const string & prop) const48 bool PropertyStore::Contains(const string& prop) const {
49 return (ContainsKey(bool_properties_, prop) ||
50 ContainsKey(int16_properties_, prop) ||
51 ContainsKey(int32_properties_, prop) ||
52 ContainsKey(key_value_store_properties_, prop) ||
53 ContainsKey(string_properties_, prop) ||
54 ContainsKey(stringmap_properties_, prop) ||
55 ContainsKey(stringmaps_properties_, prop) ||
56 ContainsKey(strings_properties_, prop) ||
57 ContainsKey(uint8_properties_, prop) ||
58 ContainsKey(bytearray_properties_, prop) ||
59 ContainsKey(uint16_properties_, prop) ||
60 ContainsKey(uint16s_properties_, prop) ||
61 ContainsKey(uint32_properties_, prop) ||
62 ContainsKey(uint64_properties_, prop) ||
63 ContainsKey(rpc_identifier_properties_, prop) ||
64 ContainsKey(rpc_identifiers_properties_, prop));
65 }
66
SetAnyProperty(const string & name,const brillo::Any & value,Error * error)67 bool PropertyStore::SetAnyProperty(const string& name,
68 const brillo::Any& value,
69 Error* error) {
70 bool ret = false;
71 if (value.IsTypeCompatible<bool>()) {
72 ret = SetBoolProperty(name, value.Get<bool>(), error);
73 } else if (value.IsTypeCompatible<uint8_t>()) {
74 ret = SetUint8Property(name, value.Get<uint8_t>(), error);
75 } else if (value.IsTypeCompatible<int16_t>()) {
76 ret = SetInt16Property(name, value.Get<int16_t>(), error);
77 } else if (value.IsTypeCompatible<int32_t>()) {
78 ret = SetInt32Property(name, value.Get<int32_t>(), error);
79 } else if (value.IsTypeCompatible<dbus::ObjectPath>()) {
80 ret = SetStringProperty(name, value.Get<dbus::ObjectPath>().value(), error);
81 } else if (value.IsTypeCompatible<string>()) {
82 ret = SetStringProperty(name, value.Get<string>(), error);
83 } else if (value.IsTypeCompatible<Stringmap>()) {
84 ret = SetStringmapProperty(name, value.Get<Stringmap>(), error);
85 } else if (value.IsTypeCompatible<Stringmaps>()) {
86 SLOG(nullptr, 1) << " can't yet handle setting type "
87 << value.GetUndecoratedTypeName();
88 error->Populate(Error::kInternalError);
89 } else if (value.IsTypeCompatible<Strings>()) {
90 ret = SetStringsProperty(name, value.Get<Strings>(), error);
91 } else if (value.IsTypeCompatible<ByteArray>()) {
92 ret = SetByteArrayProperty(name, value.Get<ByteArray>(), error);
93 } else if (value.IsTypeCompatible<uint16_t>()) {
94 ret = SetUint16Property(name, value.Get<uint16_t>(), error);
95 } else if (value.IsTypeCompatible<Uint16s>()) {
96 ret = SetUint16sProperty(name, value.Get<Uint16s>(), error);
97 } else if (value.IsTypeCompatible<uint32_t>()) {
98 ret = SetUint32Property(name, value.Get<uint32_t>(), error);
99 } else if (value.IsTypeCompatible<uint64_t>()) {
100 ret = SetUint64Property(name, value.Get<uint64_t>(), error);
101 } else if (value.IsTypeCompatible<brillo::VariantDictionary>()) {
102 KeyValueStore store;
103 KeyValueStore::ConvertFromVariantDictionary(
104 value.Get<brillo::VariantDictionary>(), &store);
105 ret = SetKeyValueStoreProperty(name, store, error);
106 } else {
107 NOTREACHED() << " unknown type: " << value.GetUndecoratedTypeName();
108 error->Populate(Error::kInternalError);
109 }
110 return ret;
111 }
112
SetProperties(const brillo::VariantDictionary & in,Error * error)113 bool PropertyStore::SetProperties(const brillo::VariantDictionary& in,
114 Error* error) {
115 for (const auto& kv : in) {
116 if (!SetAnyProperty(kv.first, kv.second, error)) {
117 return false;
118 }
119 }
120 return true;
121 }
122
GetProperties(brillo::VariantDictionary * out,Error * error) const123 bool PropertyStore::GetProperties(brillo::VariantDictionary* out,
124 Error* error) const {
125 {
126 ReadablePropertyConstIterator<bool> it = GetBoolPropertiesIter();
127 for ( ; !it.AtEnd(); it.Advance()) {
128 out->insert(std::make_pair(it.Key(), brillo::Any(it.value())));
129 }
130 }
131 {
132 ReadablePropertyConstIterator<int16_t> it = GetInt16PropertiesIter();
133 for ( ; !it.AtEnd(); it.Advance()) {
134 out->insert(std::make_pair(it.Key(), brillo::Any(it.value())));
135 }
136 }
137 {
138 ReadablePropertyConstIterator<int32_t> it = GetInt32PropertiesIter();
139 for ( ; !it.AtEnd(); it.Advance()) {
140 out->insert(std::make_pair(it.Key(), brillo::Any(it.value())));
141 }
142 }
143 {
144 ReadablePropertyConstIterator<RpcIdentifier> it =
145 GetRpcIdentifierPropertiesIter();
146 for ( ; !it.AtEnd(); it.Advance()) {
147 out->insert(
148 std::make_pair(it.Key(),
149 brillo::Any(dbus::ObjectPath(it.value()))));
150 }
151 }
152 {
153 ReadablePropertyConstIterator<RpcIdentifiers> it =
154 GetRpcIdentifiersPropertiesIter();
155 for ( ; !it.AtEnd(); it.Advance()) {
156 vector<dbus::ObjectPath> rpc_identifiers_as_paths;
157 for (const auto& path : it.value()) {
158 rpc_identifiers_as_paths.push_back(dbus::ObjectPath(path));
159 }
160 out->insert(
161 std::make_pair(it.Key(), brillo::Any(rpc_identifiers_as_paths)));
162 }
163 }
164 {
165 ReadablePropertyConstIterator<string> it = GetStringPropertiesIter();
166 for ( ; !it.AtEnd(); it.Advance()) {
167 out->insert(std::make_pair(it.Key(), brillo::Any(it.value())));
168 }
169 }
170 {
171 ReadablePropertyConstIterator<Stringmap> it = GetStringmapPropertiesIter();
172 for ( ; !it.AtEnd(); it.Advance()) {
173 out->insert(std::make_pair(it.Key(), brillo::Any(it.value())));
174 }
175 }
176 {
177 ReadablePropertyConstIterator<Stringmaps> it =
178 GetStringmapsPropertiesIter();
179 for ( ; !it.AtEnd(); it.Advance()) {
180 out->insert(std::make_pair(it.Key(), brillo::Any(it.value())));
181 }
182 }
183 {
184 ReadablePropertyConstIterator<Strings> it = GetStringsPropertiesIter();
185 for ( ; !it.AtEnd(); it.Advance()) {
186 out->insert(std::make_pair(it.Key(), brillo::Any(it.value())));
187 }
188 }
189 {
190 ReadablePropertyConstIterator<uint8_t> it = GetUint8PropertiesIter();
191 for ( ; !it.AtEnd(); it.Advance()) {
192 out->insert(std::make_pair(it.Key(), brillo::Any(it.value())));
193 }
194 }
195 {
196 ReadablePropertyConstIterator<ByteArray> it = GetByteArrayPropertiesIter();
197 for ( ; !it.AtEnd(); it.Advance()) {
198 out->insert(std::make_pair(it.Key(), brillo::Any(it.value())));
199 }
200 }
201 {
202 ReadablePropertyConstIterator<uint16_t> it = GetUint16PropertiesIter();
203 for ( ; !it.AtEnd(); it.Advance()) {
204 out->insert(std::make_pair(it.Key(), brillo::Any(it.value())));
205 }
206 }
207 {
208 ReadablePropertyConstIterator<Uint16s> it = GetUint16sPropertiesIter();
209 for ( ; !it.AtEnd(); it.Advance()) {
210 out->insert(std::make_pair(it.Key(), brillo::Any(it.value())));
211 }
212 }
213 {
214 ReadablePropertyConstIterator<uint32_t> it = GetUint32PropertiesIter();
215 for ( ; !it.AtEnd(); it.Advance()) {
216 out->insert(std::make_pair(it.Key(), brillo::Any(it.value())));
217 }
218 }
219 {
220 ReadablePropertyConstIterator<uint64_t> it = GetUint64PropertiesIter();
221 for ( ; !it.AtEnd(); it.Advance()) {
222 out->insert(std::make_pair(it.Key(), brillo::Any(it.value())));
223 }
224 }
225 {
226 ReadablePropertyConstIterator<KeyValueStore> it =
227 GetKeyValueStorePropertiesIter();
228 for ( ; !it.AtEnd(); it.Advance()) {
229 brillo::VariantDictionary dict;
230 KeyValueStore::ConvertToVariantDictionary(it.value(), &dict);
231 out->insert(std::make_pair(it.Key(), dict));
232 }
233 }
234
235 return true;
236 }
237
GetBoolProperty(const string & name,bool * value,Error * error) const238 bool PropertyStore::GetBoolProperty(const string& name,
239 bool* value,
240 Error* error) const {
241 return GetProperty(name, value, error, bool_properties_, "a bool");
242 }
243
GetInt16Property(const string & name,int16_t * value,Error * error) const244 bool PropertyStore::GetInt16Property(const string& name,
245 int16_t* value,
246 Error* error) const {
247 return GetProperty(name, value, error, int16_properties_, "an int16_t");
248 }
249
GetInt32Property(const string & name,int32_t * value,Error * error) const250 bool PropertyStore::GetInt32Property(const string& name,
251 int32_t* value,
252 Error* error) const {
253 return GetProperty(name, value, error, int32_properties_, "an int32_t");
254 }
255
GetKeyValueStoreProperty(const string & name,KeyValueStore * value,Error * error) const256 bool PropertyStore::GetKeyValueStoreProperty(const string& name,
257 KeyValueStore* value,
258 Error* error) const {
259 return GetProperty(name, value, error, key_value_store_properties_,
260 "a key value store");
261 }
262
GetRpcIdentifierProperty(const string & name,RpcIdentifier * value,Error * error) const263 bool PropertyStore::GetRpcIdentifierProperty(const string& name,
264 RpcIdentifier* value,
265 Error* error) const {
266 return GetProperty(name, value, error, rpc_identifier_properties_,
267 "an rpc_identifier");
268 }
269
GetStringProperty(const string & name,string * value,Error * error) const270 bool PropertyStore::GetStringProperty(const string& name,
271 string* value,
272 Error* error) const {
273 return GetProperty(name, value, error, string_properties_, "a string");
274 }
275
GetStringmapProperty(const string & name,Stringmap * values,Error * error) const276 bool PropertyStore::GetStringmapProperty(const string& name,
277 Stringmap* values,
278 Error* error) const {
279 return GetProperty(name, values, error, stringmap_properties_,
280 "a string map");
281 }
282
GetStringmapsProperty(const string & name,Stringmaps * values,Error * error) const283 bool PropertyStore::GetStringmapsProperty(const string& name,
284 Stringmaps* values,
285 Error* error) const {
286 return GetProperty(name, values, error, stringmaps_properties_,
287 "a string map list");
288 }
289
GetStringsProperty(const string & name,Strings * values,Error * error) const290 bool PropertyStore::GetStringsProperty(const string& name,
291 Strings* values,
292 Error* error) const {
293 return GetProperty(name, values, error, strings_properties_, "a string list");
294 }
295
GetUint8Property(const string & name,uint8_t * value,Error * error) const296 bool PropertyStore::GetUint8Property(const string& name,
297 uint8_t* value,
298 Error* error) const {
299 return GetProperty(name, value, error, uint8_properties_, "a uint8_t");
300 }
301
GetByteArrayProperty(const string & name,ByteArray * value,Error * error) const302 bool PropertyStore::GetByteArrayProperty(const string& name,
303 ByteArray* value,
304 Error *error) const {
305 return GetProperty(name, value, error, bytearray_properties_, "a byte array");
306 }
307
GetUint16Property(const string & name,uint16_t * value,Error * error) const308 bool PropertyStore::GetUint16Property(const string& name,
309 uint16_t* value,
310 Error* error) const {
311 return GetProperty(name, value, error, uint16_properties_, "a uint16_t");
312 }
313
GetUint16sProperty(const string & name,Uint16s * value,Error * error) const314 bool PropertyStore::GetUint16sProperty(const string& name,
315 Uint16s* value,
316 Error* error) const {
317 return GetProperty(name, value, error, uint16s_properties_,
318 "a uint16_t list");
319 }
320
GetUint32Property(const string & name,uint32_t * value,Error * error) const321 bool PropertyStore::GetUint32Property(const string& name,
322 uint32_t* value,
323 Error* error) const {
324 return GetProperty(name, value, error, uint32_properties_, "a uint32_t");
325 }
326
GetUint64Property(const string & name,uint64_t * value,Error * error) const327 bool PropertyStore::GetUint64Property(const string& name,
328 uint64_t* value,
329 Error* error) const {
330 return GetProperty(name, value, error, uint64_properties_, "a uint64_t");
331 }
332
SetBoolProperty(const string & name,bool value,Error * error)333 bool PropertyStore::SetBoolProperty(const string& name,
334 bool value,
335 Error* error) {
336 return SetProperty(name, value, error, &bool_properties_, "a bool");
337 }
338
SetInt16Property(const string & name,int16_t value,Error * error)339 bool PropertyStore::SetInt16Property(const string& name,
340 int16_t value,
341 Error* error) {
342 return SetProperty(name, value, error, &int16_properties_, "an int16_t");
343 }
344
SetInt32Property(const string & name,int32_t value,Error * error)345 bool PropertyStore::SetInt32Property(const string& name,
346 int32_t value,
347 Error* error) {
348 return SetProperty(name, value, error, &int32_properties_, "an int32_t.");
349 }
350
SetKeyValueStoreProperty(const string & name,const KeyValueStore & value,Error * error)351 bool PropertyStore::SetKeyValueStoreProperty(const string& name,
352 const KeyValueStore& value,
353 Error* error) {
354 return SetProperty(name, value, error, &key_value_store_properties_,
355 "a key value store");
356 }
357
SetStringProperty(const string & name,const string & value,Error * error)358 bool PropertyStore::SetStringProperty(const string& name,
359 const string& value,
360 Error* error) {
361 return SetProperty(name, value, error, &string_properties_, "a string");
362 }
363
SetStringmapProperty(const string & name,const map<string,string> & values,Error * error)364 bool PropertyStore::SetStringmapProperty(const string& name,
365 const map<string, string>& values,
366 Error* error) {
367 return SetProperty(name, values, error, &stringmap_properties_,
368 "a string map");
369 }
370
SetStringmapsProperty(const string & name,const vector<map<string,string>> & values,Error * error)371 bool PropertyStore::SetStringmapsProperty(
372 const string& name,
373 const vector<map<string, string>>& values,
374 Error* error) {
375 return SetProperty(name, values, error, &stringmaps_properties_,
376 "a stringmaps");
377 }
378
SetStringsProperty(const string & name,const vector<string> & values,Error * error)379 bool PropertyStore::SetStringsProperty(const string& name,
380 const vector<string>& values,
381 Error* error) {
382 return SetProperty(name, values, error, &strings_properties_,
383 "a string list");
384 }
385
SetUint8Property(const string & name,uint8_t value,Error * error)386 bool PropertyStore::SetUint8Property(const string& name,
387 uint8_t value,
388 Error* error) {
389 return SetProperty(name, value, error, &uint8_properties_, "a uint8_t");
390 }
391
SetByteArrayProperty(const string & name,const ByteArray & value,Error * error)392 bool PropertyStore::SetByteArrayProperty(const string& name,
393 const ByteArray& value,
394 Error *error) {
395 return SetProperty(name, value, error, &bytearray_properties_, "a byte array");
396 }
397
SetUint16Property(const string & name,uint16_t value,Error * error)398 bool PropertyStore::SetUint16Property(const string& name,
399 uint16_t value,
400 Error* error) {
401 return SetProperty(name, value, error, &uint16_properties_, "a uint16_t");
402 }
403
SetUint16sProperty(const string & name,const vector<uint16_t> & value,Error * error)404 bool PropertyStore::SetUint16sProperty(const string& name,
405 const vector<uint16_t>& value,
406 Error* error) {
407 return SetProperty(name, value, error, &uint16s_properties_,
408 "a uint16_t list");
409 }
410
SetUint32Property(const string & name,uint32_t value,Error * error)411 bool PropertyStore::SetUint32Property(const string& name,
412 uint32_t value,
413 Error* error) {
414 return SetProperty(name, value, error, &uint32_properties_, "a uint32_t");
415 }
416
SetUint64Property(const string & name,uint64_t value,Error * error)417 bool PropertyStore::SetUint64Property(const string& name,
418 uint64_t value,
419 Error* error) {
420 return SetProperty(name, value, error, &uint64_properties_, "a uint64_t");
421 }
422
SetRpcIdentifierProperty(const string & name,const RpcIdentifier & value,Error * error)423 bool PropertyStore::SetRpcIdentifierProperty(const string& name,
424 const RpcIdentifier& value,
425 Error* error) {
426 return SetProperty(name, value, error, &rpc_identifier_properties_,
427 "an rpc_identifier");
428 }
429
ClearProperty(const string & name,Error * error)430 bool PropertyStore::ClearProperty(const string& name, Error* error) {
431 SLOG(this, 2) << "Clearing " << name << ".";
432
433 if (ContainsKey(bool_properties_, name)) {
434 bool_properties_[name]->Clear(error);
435 } else if (ContainsKey(int16_properties_, name)) {
436 int16_properties_[name]->Clear(error);
437 } else if (ContainsKey(int32_properties_, name)) {
438 int32_properties_[name]->Clear(error);
439 } else if (ContainsKey(key_value_store_properties_, name)) {
440 key_value_store_properties_[name]->Clear(error);
441 } else if (ContainsKey(string_properties_, name)) {
442 string_properties_[name]->Clear(error);
443 } else if (ContainsKey(stringmap_properties_, name)) {
444 stringmap_properties_[name]->Clear(error);
445 } else if (ContainsKey(stringmaps_properties_, name)) {
446 stringmaps_properties_[name]->Clear(error);
447 } else if (ContainsKey(strings_properties_, name)) {
448 strings_properties_[name]->Clear(error);
449 } else if (ContainsKey(uint8_properties_, name)) {
450 uint8_properties_[name]->Clear(error);
451 } else if (ContainsKey(uint16_properties_, name)) {
452 uint16_properties_[name]->Clear(error);
453 } else if (ContainsKey(uint16s_properties_, name)) {
454 uint16s_properties_[name]->Clear(error);
455 } else if (ContainsKey(uint32_properties_, name)) {
456 uint32_properties_[name]->Clear(error);
457 } else if (ContainsKey(uint64_properties_, name)) {
458 uint64_properties_[name]->Clear(error);
459 } else if (ContainsKey(rpc_identifier_properties_, name)) {
460 rpc_identifier_properties_[name]->Clear(error);
461 } else if (ContainsKey(rpc_identifiers_properties_, name)) {
462 rpc_identifiers_properties_[name]->Clear(error);
463 } else {
464 error->Populate(
465 Error::kInvalidProperty, "Property " + name + " does not exist.");
466 }
467 if (error->IsSuccess()) {
468 if (!property_changed_callback_.is_null()) {
469 property_changed_callback_.Run(name);
470 }
471 }
472 return error->IsSuccess();
473 }
474
GetBoolPropertiesIter() const475 ReadablePropertyConstIterator<bool> PropertyStore::GetBoolPropertiesIter()
476 const {
477 return ReadablePropertyConstIterator<bool>(bool_properties_);
478 }
479
GetInt16PropertiesIter() const480 ReadablePropertyConstIterator<int16_t> PropertyStore::GetInt16PropertiesIter()
481 const {
482 return ReadablePropertyConstIterator<int16_t>(int16_properties_);
483 }
484
GetInt32PropertiesIter() const485 ReadablePropertyConstIterator<int32_t> PropertyStore::GetInt32PropertiesIter()
486 const {
487 return ReadablePropertyConstIterator<int32_t>(int32_properties_);
488 }
489
490 ReadablePropertyConstIterator<KeyValueStore>
GetKeyValueStorePropertiesIter() const491 PropertyStore::GetKeyValueStorePropertiesIter() const {
492 return
493 ReadablePropertyConstIterator<KeyValueStore>(key_value_store_properties_);
494 }
495
496 ReadablePropertyConstIterator<RpcIdentifier>
GetRpcIdentifierPropertiesIter() const497 PropertyStore::GetRpcIdentifierPropertiesIter() const {
498 return ReadablePropertyConstIterator<RpcIdentifier>(
499 rpc_identifier_properties_);
500 }
501
502 ReadablePropertyConstIterator<RpcIdentifiers>
GetRpcIdentifiersPropertiesIter() const503 PropertyStore::GetRpcIdentifiersPropertiesIter() const {
504 return ReadablePropertyConstIterator<RpcIdentifiers>(
505 rpc_identifiers_properties_);
506 }
507
508 ReadablePropertyConstIterator<string>
GetStringPropertiesIter() const509 PropertyStore::GetStringPropertiesIter() const {
510 return ReadablePropertyConstIterator<string>(string_properties_);
511 }
512
513 ReadablePropertyConstIterator<Stringmap>
GetStringmapPropertiesIter() const514 PropertyStore::GetStringmapPropertiesIter() const {
515 return ReadablePropertyConstIterator<Stringmap>(stringmap_properties_);
516 }
517
518 ReadablePropertyConstIterator<Stringmaps>
GetStringmapsPropertiesIter() const519 PropertyStore::GetStringmapsPropertiesIter()
520 const {
521 return ReadablePropertyConstIterator<Stringmaps>(stringmaps_properties_);
522 }
523
GetStringsPropertiesIter() const524 ReadablePropertyConstIterator<Strings> PropertyStore::GetStringsPropertiesIter()
525 const {
526 return ReadablePropertyConstIterator<Strings>(strings_properties_);
527 }
528
GetUint8PropertiesIter() const529 ReadablePropertyConstIterator<uint8_t> PropertyStore::GetUint8PropertiesIter()
530 const {
531 return ReadablePropertyConstIterator<uint8_t>(uint8_properties_);
532 }
533
GetByteArrayPropertiesIter() const534 ReadablePropertyConstIterator<ByteArray> PropertyStore::GetByteArrayPropertiesIter()
535 const {
536 return ReadablePropertyConstIterator<ByteArray>(bytearray_properties_);
537 }
538
GetUint16PropertiesIter() const539 ReadablePropertyConstIterator<uint16_t> PropertyStore::GetUint16PropertiesIter()
540 const {
541 return ReadablePropertyConstIterator<uint16_t>(uint16_properties_);
542 }
543
GetUint16sPropertiesIter() const544 ReadablePropertyConstIterator<Uint16s> PropertyStore::GetUint16sPropertiesIter()
545 const {
546 return ReadablePropertyConstIterator<Uint16s>(uint16s_properties_);
547 }
548
GetUint32PropertiesIter() const549 ReadablePropertyConstIterator<uint32_t> PropertyStore::GetUint32PropertiesIter()
550 const {
551 return ReadablePropertyConstIterator<uint32_t>(uint32_properties_);
552 }
553
GetUint64PropertiesIter() const554 ReadablePropertyConstIterator<uint64_t> PropertyStore::GetUint64PropertiesIter()
555 const {
556 return ReadablePropertyConstIterator<uint64_t>(uint64_properties_);
557 }
558
RegisterBool(const string & name,bool * prop)559 void PropertyStore::RegisterBool(const string& name, bool* prop) {
560 DCHECK(!Contains(name) || ContainsKey(bool_properties_, name))
561 << "(Already registered " << name << ")";
562 bool_properties_[name] = BoolAccessor(new PropertyAccessor<bool>(prop));
563 }
564
RegisterConstBool(const string & name,const bool * prop)565 void PropertyStore::RegisterConstBool(const string& name, const bool* prop) {
566 DCHECK(!Contains(name) || ContainsKey(bool_properties_, name))
567 << "(Already registered " << name << ")";
568 bool_properties_[name] = BoolAccessor(new ConstPropertyAccessor<bool>(prop));
569 }
570
RegisterWriteOnlyBool(const string & name,bool * prop)571 void PropertyStore::RegisterWriteOnlyBool(const string& name, bool* prop) {
572 DCHECK(!Contains(name) || ContainsKey(bool_properties_, name))
573 << "(Already registered " << name << ")";
574 bool_properties_[name] = BoolAccessor(
575 new WriteOnlyPropertyAccessor<bool>(prop));
576 }
577
RegisterInt16(const string & name,int16_t * prop)578 void PropertyStore::RegisterInt16(const string& name, int16_t* prop) {
579 DCHECK(!Contains(name) || ContainsKey(int16_properties_, name))
580 << "(Already registered " << name << ")";
581 int16_properties_[name] = Int16Accessor(new PropertyAccessor<int16_t>(prop));
582 }
583
RegisterConstInt16(const string & name,const int16_t * prop)584 void PropertyStore::RegisterConstInt16(const string& name,
585 const int16_t* prop) {
586 DCHECK(!Contains(name) || ContainsKey(int16_properties_, name))
587 << "(Already registered " << name << ")";
588 int16_properties_[name] =
589 Int16Accessor(new ConstPropertyAccessor<int16_t>(prop));
590 }
591
RegisterWriteOnlyInt16(const string & name,int16_t * prop)592 void PropertyStore::RegisterWriteOnlyInt16(const string& name, int16_t* prop) {
593 DCHECK(!Contains(name) || ContainsKey(int16_properties_, name))
594 << "(Already registered " << name << ")";
595 int16_properties_[name] =
596 Int16Accessor(new WriteOnlyPropertyAccessor<int16_t>(prop));
597 }
RegisterInt32(const string & name,int32_t * prop)598 void PropertyStore::RegisterInt32(const string& name, int32_t* prop) {
599 DCHECK(!Contains(name) || ContainsKey(int32_properties_, name))
600 << "(Already registered " << name << ")";
601 int32_properties_[name] = Int32Accessor(new PropertyAccessor<int32_t>(prop));
602 }
603
RegisterConstInt32(const string & name,const int32_t * prop)604 void PropertyStore::RegisterConstInt32(const string& name,
605 const int32_t* prop) {
606 DCHECK(!Contains(name) || ContainsKey(int32_properties_, name))
607 << "(Already registered " << name << ")";
608 int32_properties_[name] =
609 Int32Accessor(new ConstPropertyAccessor<int32_t>(prop));
610 }
611
RegisterWriteOnlyInt32(const string & name,int32_t * prop)612 void PropertyStore::RegisterWriteOnlyInt32(const string& name, int32_t* prop) {
613 DCHECK(!Contains(name) || ContainsKey(int32_properties_, name))
614 << "(Already registered " << name << ")";
615 int32_properties_[name] =
616 Int32Accessor(new WriteOnlyPropertyAccessor<int32_t>(prop));
617 }
618
RegisterString(const string & name,string * prop)619 void PropertyStore::RegisterString(const string& name, string* prop) {
620 DCHECK(!Contains(name) || ContainsKey(string_properties_, name))
621 << "(Already registered " << name << ")";
622 string_properties_[name] = StringAccessor(new PropertyAccessor<string>(prop));
623 }
624
RegisterConstString(const string & name,const string * prop)625 void PropertyStore::RegisterConstString(const string& name,
626 const string* prop) {
627 DCHECK(!Contains(name) || ContainsKey(string_properties_, name))
628 << "(Already registered " << name << ")";
629 string_properties_[name] =
630 StringAccessor(new ConstPropertyAccessor<string>(prop));
631 }
632
RegisterWriteOnlyString(const string & name,string * prop)633 void PropertyStore::RegisterWriteOnlyString(const string& name, string* prop) {
634 DCHECK(!Contains(name) || ContainsKey(string_properties_, name))
635 << "(Already registered " << name << ")";
636 string_properties_[name] =
637 StringAccessor(new WriteOnlyPropertyAccessor<string>(prop));
638 }
639
RegisterStringmap(const string & name,Stringmap * prop)640 void PropertyStore::RegisterStringmap(const string& name, Stringmap* prop) {
641 DCHECK(!Contains(name) || ContainsKey(stringmap_properties_, name))
642 << "(Already registered " << name << ")";
643 stringmap_properties_[name] =
644 StringmapAccessor(new PropertyAccessor<Stringmap>(prop));
645 }
646
RegisterConstStringmap(const string & name,const Stringmap * prop)647 void PropertyStore::RegisterConstStringmap(const string& name,
648 const Stringmap* prop) {
649 DCHECK(!Contains(name) || ContainsKey(stringmap_properties_, name))
650 << "(Already registered " << name << ")";
651 stringmap_properties_[name] =
652 StringmapAccessor(new ConstPropertyAccessor<Stringmap>(prop));
653 }
654
RegisterWriteOnlyStringmap(const string & name,Stringmap * prop)655 void PropertyStore::RegisterWriteOnlyStringmap(const string& name,
656 Stringmap* prop) {
657 DCHECK(!Contains(name) || ContainsKey(stringmap_properties_, name))
658 << "(Already registered " << name << ")";
659 stringmap_properties_[name] =
660 StringmapAccessor(new WriteOnlyPropertyAccessor<Stringmap>(prop));
661 }
662
RegisterStringmaps(const string & name,Stringmaps * prop)663 void PropertyStore::RegisterStringmaps(const string& name, Stringmaps* prop) {
664 DCHECK(!Contains(name) || ContainsKey(stringmaps_properties_, name))
665 << "(Already registered " << name << ")";
666 stringmaps_properties_[name] =
667 StringmapsAccessor(new PropertyAccessor<Stringmaps>(prop));
668 }
669
RegisterConstStringmaps(const string & name,const Stringmaps * prop)670 void PropertyStore::RegisterConstStringmaps(const string& name,
671 const Stringmaps* prop) {
672 DCHECK(!Contains(name) || ContainsKey(stringmaps_properties_, name))
673 << "(Already registered " << name << ")";
674 stringmaps_properties_[name] =
675 StringmapsAccessor(new ConstPropertyAccessor<Stringmaps>(prop));
676 }
677
RegisterWriteOnlyStringmaps(const string & name,Stringmaps * prop)678 void PropertyStore::RegisterWriteOnlyStringmaps(const string& name,
679 Stringmaps* prop) {
680 DCHECK(!Contains(name) || ContainsKey(stringmaps_properties_, name))
681 << "(Already registered " << name << ")";
682 stringmaps_properties_[name] =
683 StringmapsAccessor(new WriteOnlyPropertyAccessor<Stringmaps>(prop));
684 }
685
RegisterStrings(const string & name,Strings * prop)686 void PropertyStore::RegisterStrings(const string& name, Strings* prop) {
687 DCHECK(!Contains(name) || ContainsKey(strings_properties_, name))
688 << "(Already registered " << name << ")";
689 strings_properties_[name] =
690 StringsAccessor(new PropertyAccessor<Strings>(prop));
691 }
692
RegisterConstStrings(const string & name,const Strings * prop)693 void PropertyStore::RegisterConstStrings(const string& name,
694 const Strings* prop) {
695 DCHECK(!Contains(name) || ContainsKey(strings_properties_, name))
696 << "(Already registered " << name << ")";
697 strings_properties_[name] =
698 StringsAccessor(new ConstPropertyAccessor<Strings>(prop));
699 }
700
RegisterWriteOnlyStrings(const string & name,Strings * prop)701 void PropertyStore::RegisterWriteOnlyStrings(const string& name,
702 Strings* prop) {
703 DCHECK(!Contains(name) || ContainsKey(strings_properties_, name))
704 << "(Already registered " << name << ")";
705 strings_properties_[name] =
706 StringsAccessor(new WriteOnlyPropertyAccessor<Strings>(prop));
707 }
708
RegisterUint8(const string & name,uint8_t * prop)709 void PropertyStore::RegisterUint8(const string& name, uint8_t* prop) {
710 DCHECK(!Contains(name) || ContainsKey(uint8_properties_, name))
711 << "(Already registered " << name << ")";
712 uint8_properties_[name] = Uint8Accessor(new PropertyAccessor<uint8_t>(prop));
713 }
714
RegisterConstUint8(const string & name,const uint8_t * prop)715 void PropertyStore::RegisterConstUint8(const string& name,
716 const uint8_t* prop) {
717 DCHECK(!Contains(name) || ContainsKey(uint8_properties_, name))
718 << "(Already registered " << name << ")";
719 uint8_properties_[name] =
720 Uint8Accessor(new ConstPropertyAccessor<uint8_t>(prop));
721 }
722
RegisterWriteOnlyUint8(const string & name,uint8_t * prop)723 void PropertyStore::RegisterWriteOnlyUint8(const string& name, uint8_t* prop) {
724 DCHECK(!Contains(name) || ContainsKey(uint8_properties_, name))
725 << "(Already registered " << name << ")";
726 uint8_properties_[name] =
727 Uint8Accessor(new WriteOnlyPropertyAccessor<uint8_t>(prop));
728 }
729
RegisterByteArray(const string & name,ByteArray * prop)730 void PropertyStore::RegisterByteArray(const string& name, ByteArray* prop) {
731 DCHECK(!Contains(name) || ContainsKey(bytearray_properties_, name))
732 << "(Already registered " << name << ")";
733 bytearray_properties_[name] =
734 ByteArrayAccessor(new PropertyAccessor<ByteArray>(prop));
735 }
736
RegisterConstByteArray(const string & name,const ByteArray * prop)737 void PropertyStore::RegisterConstByteArray(const string& name,
738 const ByteArray* prop) {
739 DCHECK(!Contains(name) || ContainsKey(bytearray_properties_, name))
740 << "(Already registered " << name << ")";
741 bytearray_properties_[name] =
742 ByteArrayAccessor(new ConstPropertyAccessor<ByteArray>(prop));
743 }
744
RegisterWriteOnlyByteArray(const string & name,ByteArray * prop)745 void PropertyStore::RegisterWriteOnlyByteArray(const string& name,
746 ByteArray* prop) {
747 DCHECK(!Contains(name) || ContainsKey(bytearray_properties_, name))
748 << "(Already registered " << name << ")";
749 bytearray_properties_[name] =
750 ByteArrayAccessor(new WriteOnlyPropertyAccessor<ByteArray>(prop));
751 }
752
RegisterUint16(const string & name,uint16_t * prop)753 void PropertyStore::RegisterUint16(const string& name, uint16_t* prop) {
754 DCHECK(!Contains(name) || ContainsKey(uint16_properties_, name))
755 << "(Already registered " << name << ")";
756 uint16_properties_[name] =
757 Uint16Accessor(new PropertyAccessor<uint16_t>(prop));
758 }
759
RegisterUint16s(const string & name,Uint16s * prop)760 void PropertyStore::RegisterUint16s(const string& name, Uint16s* prop) {
761 DCHECK(!Contains(name) || ContainsKey(uint16s_properties_, name))
762 << "(Already registered " << name << ")";
763 uint16s_properties_[name] =
764 Uint16sAccessor(new PropertyAccessor<Uint16s>(prop));
765 }
766
RegisterUint32(const std::string & name,uint32_t * prop)767 void PropertyStore::RegisterUint32(const std::string& name, uint32_t* prop) {
768 DCHECK(!Contains(name) || ContainsKey(uint32_properties_, name))
769 << "(Already registered " << name << ")";
770 uint32_properties_[name] =
771 Uint32Accessor(new PropertyAccessor<uint32_t>(prop));
772 }
773
RegisterConstUint32(const string & name,const uint32_t * prop)774 void PropertyStore::RegisterConstUint32(const string& name,
775 const uint32_t* prop) {
776 DCHECK(!Contains(name) || ContainsKey(uint32_properties_, name))
777 << "(Already registered " << name << ")";
778 uint32_properties_[name] =
779 Uint32Accessor(new ConstPropertyAccessor<uint32_t>(prop));
780 }
781
RegisterConstUint16(const string & name,const uint16_t * prop)782 void PropertyStore::RegisterConstUint16(const string& name,
783 const uint16_t* prop) {
784 DCHECK(!Contains(name) || ContainsKey(uint16_properties_, name))
785 << "(Already registered " << name << ")";
786 uint16_properties_[name] =
787 Uint16Accessor(new ConstPropertyAccessor<uint16_t>(prop));
788 }
789
RegisterConstUint16s(const string & name,const Uint16s * prop)790 void PropertyStore::RegisterConstUint16s(const string& name,
791 const Uint16s* prop) {
792 DCHECK(!Contains(name) || ContainsKey(uint16s_properties_, name))
793 << "(Already registered " << name << ")";
794 uint16s_properties_[name] =
795 Uint16sAccessor(new ConstPropertyAccessor<Uint16s>(prop));
796 }
797
RegisterWriteOnlyUint16(const string & name,uint16_t * prop)798 void PropertyStore::RegisterWriteOnlyUint16(const string& name,
799 uint16_t* prop) {
800 DCHECK(!Contains(name) || ContainsKey(uint16_properties_, name))
801 << "(Already registered " << name << ")";
802 uint16_properties_[name] =
803 Uint16Accessor(new WriteOnlyPropertyAccessor<uint16_t>(prop));
804 }
805
RegisterDerivedBool(const string & name,const BoolAccessor & accessor)806 void PropertyStore::RegisterDerivedBool(const string& name,
807 const BoolAccessor& accessor) {
808 DCHECK(!Contains(name) || ContainsKey(bool_properties_, name))
809 << "(Already registered " << name << ")";
810 bool_properties_[name] = accessor;
811 }
812
RegisterDerivedInt32(const string & name,const Int32Accessor & accessor)813 void PropertyStore::RegisterDerivedInt32(const string& name,
814 const Int32Accessor& accessor) {
815 DCHECK(!Contains(name) || ContainsKey(int32_properties_, name))
816 << "(Already registered " << name << ")";
817 int32_properties_[name] = accessor;
818 }
819
RegisterDerivedKeyValueStore(const string & name,const KeyValueStoreAccessor & acc)820 void PropertyStore::RegisterDerivedKeyValueStore(
821 const string& name,
822 const KeyValueStoreAccessor& acc) {
823 DCHECK(!Contains(name) || ContainsKey(key_value_store_properties_, name))
824 << "(Already registered " << name << ")";
825 key_value_store_properties_[name] = acc;
826 }
827
RegisterDerivedRpcIdentifier(const string & name,const RpcIdentifierAccessor & acc)828 void PropertyStore::RegisterDerivedRpcIdentifier(
829 const string& name,
830 const RpcIdentifierAccessor& acc) {
831 DCHECK(!Contains(name) || ContainsKey(rpc_identifier_properties_, name))
832 << "(Already registered " << name << ")";
833 rpc_identifier_properties_[name] = acc;
834 }
835
RegisterDerivedRpcIdentifiers(const string & name,const RpcIdentifiersAccessor & accessor)836 void PropertyStore::RegisterDerivedRpcIdentifiers(
837 const string& name,
838 const RpcIdentifiersAccessor& accessor) {
839 DCHECK(!Contains(name) || ContainsKey(rpc_identifiers_properties_, name))
840 << "(Already registered " << name << ")";
841 rpc_identifiers_properties_[name] = accessor;
842 }
843
RegisterDerivedString(const string & name,const StringAccessor & accessor)844 void PropertyStore::RegisterDerivedString(const string& name,
845 const StringAccessor& accessor) {
846 DCHECK(!Contains(name) || ContainsKey(string_properties_, name))
847 << "(Already registered " << name << ")";
848 string_properties_[name] = accessor;
849 }
850
RegisterDerivedStrings(const string & name,const StringsAccessor & accessor)851 void PropertyStore::RegisterDerivedStrings(const string& name,
852 const StringsAccessor& accessor) {
853 DCHECK(!Contains(name) || ContainsKey(strings_properties_, name))
854 << "(Already registered " << name << ")";
855 strings_properties_[name] = accessor;
856 }
857
RegisterDerivedStringmap(const string & name,const StringmapAccessor & acc)858 void PropertyStore::RegisterDerivedStringmap(const string& name,
859 const StringmapAccessor& acc) {
860 DCHECK(!Contains(name) || ContainsKey(stringmap_properties_, name))
861 << "(Already registered " << name << ")";
862 stringmap_properties_[name] = acc;
863 }
864
RegisterDerivedStringmaps(const string & name,const StringmapsAccessor & acc)865 void PropertyStore::RegisterDerivedStringmaps(const string& name,
866 const StringmapsAccessor& acc) {
867 DCHECK(!Contains(name) || ContainsKey(stringmaps_properties_, name))
868 << "(Already registered " << name << ")";
869 stringmaps_properties_[name] = acc;
870 }
871
RegisterDerivedUint16(const string & name,const Uint16Accessor & acc)872 void PropertyStore::RegisterDerivedUint16(const string& name,
873 const Uint16Accessor& acc) {
874 DCHECK(!Contains(name) || ContainsKey(uint16_properties_, name))
875 << "(Already registered " << name << ")";
876 uint16_properties_[name] = acc;
877 }
878
RegisterDerivedUint64(const string & name,const Uint64Accessor & acc)879 void PropertyStore::RegisterDerivedUint64(const string& name,
880 const Uint64Accessor& acc) {
881 DCHECK(!Contains(name) || ContainsKey(uint64_properties_, name))
882 << "(Already registered " << name << ")";
883 uint64_properties_[name] = acc;
884 }
885
RegisterDerivedByteArray(const string & name,const ByteArrayAccessor & acc)886 void PropertyStore::RegisterDerivedByteArray(const string& name,
887 const ByteArrayAccessor& acc) {
888 DCHECK(!Contains(name) || ContainsKey(bytearray_properties_, name))
889 << "(Already registered " << name << ")";
890 bytearray_properties_[name] = acc;
891 }
892
893 // private methods
894
895 template <class V>
GetProperty(const string & name,V * value,Error * error,const map<string,std::shared_ptr<AccessorInterface<V>>> & collection,const string & value_type_english) const896 bool PropertyStore::GetProperty(
897 const string& name,
898 V* value,
899 Error* error,
900 const map<string, std::shared_ptr<AccessorInterface<V>>>& collection,
901 const string& value_type_english) const {
902 SLOG(this, 2) << "Getting " << name << " as " << value_type_english
903 << ".";
904 typename map<string, std::shared_ptr<AccessorInterface<V>>>::const_iterator
905 it = collection.find(name);
906 if (it != collection.end()) {
907 V val = it->second->Get(error);
908 if (error->IsSuccess()) {
909 *value = val;
910 }
911 } else {
912 if (Contains(name)) {
913 error->Populate(
914 Error::kInvalidArguments,
915 "Property " + name + " is not " + value_type_english + ".");
916 } else {
917 error->Populate(
918 Error::kInvalidProperty, "Property " + name + " does not exist.");
919 }
920 }
921 return error->IsSuccess();
922 }
923
924 template <class V>
SetProperty(const string & name,const V & value,Error * error,map<string,std::shared_ptr<AccessorInterface<V>>> * collection,const string & value_type_english)925 bool PropertyStore::SetProperty(
926 const string& name,
927 const V& value,
928 Error* error,
929 map<string, std::shared_ptr<AccessorInterface<V>>>* collection,
930 const string& value_type_english) {
931 bool ret = false;
932 SLOG(this, 2) << "Setting " << name << " as " << value_type_english
933 << ".";
934 if (ContainsKey(*collection, name)) {
935 ret = (*collection)[name]->Set(value, error);
936 if (ret) {
937 if (!property_changed_callback_.is_null()) {
938 property_changed_callback_.Run(name);
939 }
940 }
941 } else {
942 if (Contains(name)) {
943 error->Populate(
944 Error::kInvalidArguments,
945 "Property " + name + " is not " + value_type_english + ".");
946 } else {
947 error->Populate(
948 Error::kInvalidProperty, "Property " + name + " does not exist.");
949 }
950 }
951 return ret;
952 }
953
954 } // namespace shill
955