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 #ifndef SHILL_ACCESSOR_INTERFACE_H_
18 #define SHILL_ACCESSOR_INTERFACE_H_
19 
20 #include <map>
21 #include <memory>
22 #include <string>
23 #include <utility>
24 #include <vector>
25 
26 #include <base/macros.h>
27 
28 #include "shill/key_value_store.h"
29 
30 namespace shill {
31 
32 class Error;
33 
34 // A templated abstract base class for objects that can be used to access
35 // properties stored in objects that are meant to be made available over RPC.
36 // The intended usage is that an object stores a maps of strings to
37 // AccessorInterfaces of the appropriate type, and then uses
38 // map[name]->Get() and map[name]->Set(value) to get and set the properties.
39 template <class T>
40 class AccessorInterface {
41  public:
AccessorInterface()42   AccessorInterface() {}
~AccessorInterface()43   virtual ~AccessorInterface() {}
44 
45   // Reset the property to its default value. Sets |error| on failure.
46   virtual void Clear(Error* error) = 0;
47   // Provides read-only access. Sets |error| on failure.
48   virtual T Get(Error* error) = 0;
49   // Attempts to set the wrapped value. Sets |error| on failure.  The
50   // return value indicates whether or not the wrapped value was
51   // modified. If the new value is the same as the old value, Set
52   // returns false, but with |error| unchanged.
53   virtual bool Set(const T& value, Error* error) = 0;
54 
55  private:
56   DISALLOW_COPY_AND_ASSIGN(AccessorInterface);
57 };
58 
59 typedef std::vector<uint8_t> ByteArray;
60 typedef std::vector<ByteArray> ByteArrays;
61 // Note that while the RpcIdentifiers type has the same concrete
62 // representation as the Strings type, it may be serialized
63 // differently. Accordingly, PropertyStore tracks RpcIdentifiers
64 // separately from Strings. We create a separate typedef here, to make
65 // the PropertyStore-related code read more simply.
66 typedef std::string RpcIdentifier;
67 typedef std::vector<std::string> RpcIdentifiers;
68 typedef std::vector<std::string> Strings;
69 typedef std::map<std::string, std::string> Stringmap;
70 typedef std::vector<Stringmap> Stringmaps;
71 typedef std::vector<uint16_t> Uint16s;
72 
73 // Using a smart pointer here allows pointers to classes derived from
74 // AccessorInterface<> to be stored in maps and other STL container types.
75 typedef std::shared_ptr<AccessorInterface<bool>> BoolAccessor;
76 typedef std::shared_ptr<AccessorInterface<int16_t>> Int16Accessor;
77 typedef std::shared_ptr<AccessorInterface<int32_t>> Int32Accessor;
78 // See comment above RpcIdentifiers typedef, for the reason why the
79 // RpcIdentifiersAccessor exists (even though it has the same
80 // underlying type as StringsAccessor).
81 typedef std::shared_ptr<
82     AccessorInterface<RpcIdentifier>> RpcIdentifierAccessor;
83 typedef std::shared_ptr<
84     AccessorInterface<std::vector<std::string>>> RpcIdentifiersAccessor;
85 typedef std::shared_ptr<AccessorInterface<std::string>> StringAccessor;
86 typedef std::shared_ptr<AccessorInterface<Stringmap>> StringmapAccessor;
87 typedef std::shared_ptr<AccessorInterface<Stringmaps>> StringmapsAccessor;
88 typedef std::shared_ptr<AccessorInterface<Strings>> StringsAccessor;
89 typedef std::shared_ptr<
90     AccessorInterface<KeyValueStore>> KeyValueStoreAccessor;
91 typedef std::shared_ptr<AccessorInterface<uint8_t>> Uint8Accessor;
92 typedef std::shared_ptr<AccessorInterface<ByteArray>> ByteArrayAccessor;
93 typedef std::shared_ptr<AccessorInterface<uint16_t>> Uint16Accessor;
94 typedef std::shared_ptr<AccessorInterface<Uint16s>> Uint16sAccessor;
95 typedef std::shared_ptr<AccessorInterface<uint32_t>> Uint32Accessor;
96 typedef std::shared_ptr<AccessorInterface<uint64_t>> Uint64Accessor;
97 
98 }  // namespace shill
99 
100 #endif  // SHILL_ACCESSOR_INTERFACE_H_
101