]>
Commit | Line | Data |
---|---|---|
20effc67 TL |
1 | // Copyright (c) 2011-present, Facebook, Inc. All rights reserved. |
2 | // This source code is licensed under both the GPLv2 (found in the | |
3 | // COPYING file in the root directory) and Apache 2.0 License | |
4 | // (found in the LICENSE.Apache file in the root directory). | |
5 | ||
6 | #pragma once | |
7 | #include <functional> | |
8 | #include <memory> | |
9 | #include <unordered_map> | |
10 | ||
11 | #include "options/configurable_helper.h" | |
12 | #include "options/options_helper.h" | |
13 | #include "rocksdb/convenience.h" | |
14 | #include "rocksdb/customizable.h" | |
15 | #include "rocksdb/status.h" | |
16 | #include "rocksdb/utilities/object_registry.h" | |
17 | ||
18 | namespace ROCKSDB_NAMESPACE { | |
19 | template <typename T> | |
20 | using SharedFactoryFunc = | |
21 | std::function<bool(const std::string&, std::shared_ptr<T>*)>; | |
22 | ||
23 | template <typename T> | |
24 | using UniqueFactoryFunc = | |
25 | std::function<bool(const std::string&, std::unique_ptr<T>*)>; | |
26 | ||
27 | template <typename T> | |
28 | using StaticFactoryFunc = std::function<bool(const std::string&, T**)>; | |
29 | ||
30 | // Creates a new shared Customizable object based on the input parameters. | |
31 | // This method parses the input value to determine the type of instance to | |
32 | // create. If there is an existing instance (in result) and it is the same type | |
33 | // as the object being created, the existing configuration is stored and used as | |
34 | // the default for the new object. | |
35 | // | |
36 | // The value parameter specified the instance class of the object to create. | |
37 | // If it is a simple string (e.g. BlockBasedTable), then the instance will be | |
38 | // created using the default settings. If the value is a set of name-value | |
39 | // pairs, then the "id" value is used to determine the instance to create and | |
40 | // the remaining parameters are used to configure the object. Id name-value | |
41 | // pairs are specified, there must be an "id=value" pairing or an error will | |
42 | // result. | |
43 | // | |
44 | // The config_options parameter controls the process and how errors are | |
45 | // returned. If ignore_unknown_options=true, unknown values are ignored during | |
46 | // the configuration If ignore_unsupported_options=true, unknown instance types | |
47 | // are ignored If invoke_prepare_options=true, the resulting instance wll be | |
48 | // initialized (via PrepareOptions | |
49 | // | |
50 | // @param config_options Controls how the instance is created and errors are | |
51 | // handled | |
52 | // @param value Either the simple name of the instance to create, or a set of | |
53 | // name-value pairs to | |
54 | // create and initailzie the object | |
55 | // @param func Optional function to call to attempt to create an instance | |
56 | // @param result The newly created instance. | |
57 | template <typename T> | |
58 | static Status LoadSharedObject(const ConfigOptions& config_options, | |
59 | const std::string& value, | |
60 | const SharedFactoryFunc<T>& func, | |
61 | std::shared_ptr<T>* result) { | |
62 | std::string id; | |
63 | std::unordered_map<std::string, std::string> opt_map; | |
64 | Status status = ConfigurableHelper::GetOptionsMap(value, &id, &opt_map); | |
65 | if (!status.ok()) { // GetOptionsMap failed | |
66 | return status; | |
67 | } | |
68 | std::string curr_opts; | |
69 | #ifndef ROCKSDB_LITE | |
70 | if (result->get() != nullptr && result->get()->GetId() == id) { | |
71 | // Try to get the existing options, ignoring any errors | |
72 | ConfigOptions embedded = config_options; | |
73 | embedded.delimiter = ";"; | |
74 | result->get()->GetOptionString(embedded, &curr_opts).PermitUncheckedError(); | |
75 | } | |
76 | #endif | |
77 | if (func == nullptr || !func(id, result)) { // No factory, or it failed | |
78 | if (id.empty() && opt_map.empty()) { | |
79 | // No Id and no options. Clear the object | |
80 | result->reset(); | |
81 | return Status::OK(); | |
82 | } else if (id.empty()) { // We have no Id but have options. Not good | |
83 | return Status::NotSupported("Cannot reset object ", id); | |
84 | } else { | |
85 | #ifndef ROCKSDB_LITE | |
86 | status = ObjectRegistry::NewInstance()->NewSharedObject(id, result); | |
87 | #else | |
88 | status = Status::NotSupported("Cannot load object in LITE mode ", id); | |
89 | #endif | |
90 | if (!status.ok()) { | |
91 | if (config_options.ignore_unsupported_options) { | |
92 | return Status::OK(); | |
93 | } else { | |
94 | return status; | |
95 | } | |
96 | } | |
97 | } | |
98 | } | |
99 | return ConfigurableHelper::ConfigureNewObject(config_options, result->get(), | |
100 | id, curr_opts, opt_map); | |
101 | } | |
102 | ||
103 | // Creates a new unique customizable instance object based on the input | |
104 | // parameters. | |
105 | // @see LoadSharedObject for more information on the inner workings of this | |
106 | // method. | |
107 | // | |
108 | // @param config_options Controls how the instance is created and errors are | |
109 | // handled | |
110 | // @param value Either the simple name of the instance to create, or a set of | |
111 | // name-value pairs to | |
112 | // create and initailzie the object | |
113 | // @param func Optional function to call to attempt to create an instance | |
114 | // @param result The newly created instance. | |
115 | template <typename T> | |
116 | static Status LoadUniqueObject(const ConfigOptions& config_options, | |
117 | const std::string& value, | |
118 | const UniqueFactoryFunc<T>& func, | |
119 | std::unique_ptr<T>* result) { | |
120 | std::string id; | |
121 | std::unordered_map<std::string, std::string> opt_map; | |
122 | Status status = ConfigurableHelper::GetOptionsMap(value, &id, &opt_map); | |
123 | if (!status.ok()) { // GetOptionsMap failed | |
124 | return status; | |
125 | } | |
126 | std::string curr_opts; | |
127 | #ifndef ROCKSDB_LITE | |
128 | if (result->get() != nullptr && result->get()->GetId() == id) { | |
129 | // Try to get the existing options, ignoring any errors | |
130 | ConfigOptions embedded = config_options; | |
131 | embedded.delimiter = ";"; | |
132 | result->get()->GetOptionString(embedded, &curr_opts).PermitUncheckedError(); | |
133 | } | |
134 | #endif | |
135 | if (func == nullptr || !func(id, result)) { // No factory, or it failed | |
136 | if (id.empty() && opt_map.empty()) { | |
137 | // No Id and no options. Clear the object | |
138 | result->reset(); | |
139 | return Status::OK(); | |
140 | } else if (id.empty()) { // We have no Id but have options. Not good | |
141 | return Status::NotSupported("Cannot reset object ", id); | |
142 | } else { | |
143 | #ifndef ROCKSDB_LITE | |
144 | status = ObjectRegistry::NewInstance()->NewUniqueObject(id, result); | |
145 | #else | |
146 | status = Status::NotSupported("Cannot load object in LITE mode ", id); | |
147 | #endif // ROCKSDB_LITE | |
148 | if (!status.ok()) { | |
149 | if (config_options.ignore_unsupported_options) { | |
150 | return Status::OK(); | |
151 | } else { | |
152 | return status; | |
153 | } | |
154 | } | |
155 | } | |
156 | } | |
157 | return ConfigurableHelper::ConfigureNewObject(config_options, result->get(), | |
158 | id, curr_opts, opt_map); | |
159 | } | |
160 | // Creates a new static (raw pointer) customizable instance object based on the | |
161 | // input parameters. | |
162 | // @see LoadSharedObject for more information on the inner workings of this | |
163 | // method. | |
164 | // | |
165 | // @param config_options Controls how the instance is created and errors are | |
166 | // handled | |
167 | // @param value Either the simple name of the instance to create, or a set of | |
168 | // name-value pairs to | |
169 | // create and initailzie the object | |
170 | // @param func Optional function to call to attempt to create an instance | |
171 | // @param result The newly created instance. | |
172 | template <typename T> | |
173 | static Status LoadStaticObject(const ConfigOptions& config_options, | |
174 | const std::string& value, | |
175 | const StaticFactoryFunc<T>& func, T** result) { | |
176 | std::string id; | |
177 | std::unordered_map<std::string, std::string> opt_map; | |
178 | Status status = ConfigurableHelper::GetOptionsMap(value, &id, &opt_map); | |
179 | if (!status.ok()) { // GetOptionsMap failed | |
180 | return status; | |
181 | } | |
182 | std::string curr_opts; | |
183 | #ifndef ROCKSDB_LITE | |
184 | if (*result != nullptr && (*result)->GetId() == id) { | |
185 | // Try to get the existing options, ignoring any errors | |
186 | ConfigOptions embedded = config_options; | |
187 | embedded.delimiter = ";"; | |
188 | (*result)->GetOptionString(embedded, &curr_opts).PermitUncheckedError(); | |
189 | } | |
190 | #endif | |
191 | if (func == nullptr || !func(id, result)) { // No factory, or it failed | |
192 | if (id.empty() && opt_map.empty()) { | |
193 | // No Id and no options. Clear the object | |
194 | *result = nullptr; | |
195 | return Status::OK(); | |
196 | } else if (id.empty()) { // We have no Id but have options. Not good | |
197 | return Status::NotSupported("Cannot reset object ", id); | |
198 | } else { | |
199 | #ifndef ROCKSDB_LITE | |
200 | status = ObjectRegistry::NewInstance()->NewStaticObject(id, result); | |
201 | #else | |
202 | status = Status::NotSupported("Cannot load object in LITE mode ", id); | |
203 | #endif // ROCKSDB_LITE | |
204 | if (!status.ok()) { | |
205 | if (config_options.ignore_unsupported_options) { | |
206 | return Status::OK(); | |
207 | } else { | |
208 | return status; | |
209 | } | |
210 | } | |
211 | } | |
212 | } | |
213 | return ConfigurableHelper::ConfigureNewObject(config_options, *result, id, | |
214 | curr_opts, opt_map); | |
215 | } | |
216 | } // namespace ROCKSDB_NAMESPACE |