@nxtedition/rocksdb 1.0.0

package/deps/rocksdb/rocksdb/options/configurable_test.h

@@ -0,0 +1,127 @@
+//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
+//
+// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file. See the AUTHORS file for names of contributors.
+
+#pragma once
+#include <algorithm>
+#include <memory>
+#include <unordered_map>
+
+#include "options/configurable_helper.h"
+#include "rocksdb/configurable.h"
+#include "rocksdb/utilities/options_type.h"
+
+namespace ROCKSDB_NAMESPACE {
+struct ColumnFamilyOptions;
+struct DBOptions;
+
+namespace test {
+enum TestEnum { kTestA, kTestB };
+
+static const std::unordered_map<std::string, int> test_enum_map = {
+    {"A", TestEnum::kTestA},
+    {"B", TestEnum::kTestB},
+};
+
+struct TestOptions {
+  int i = 0;
+  bool b = false;
+  bool d = true;
+  TestEnum e = TestEnum::kTestA;
+  std::string s = "";
+  std::string u = "";
+};
+
+static std::unordered_map<std::string, OptionTypeInfo> simple_option_info = {
+#ifndef ROCKSDB_LITE
+    {"int",
+     {offsetof(struct TestOptions, i), OptionType::kInt,
+      OptionVerificationType::kNormal, OptionTypeFlags::kMutable}},
+    {"bool",
+     {offsetof(struct TestOptions, b), OptionType::kBoolean,
+      OptionVerificationType::kNormal, OptionTypeFlags::kNone}},
+    {"string",
+     {offsetof(struct TestOptions, s), OptionType::kString,
+      OptionVerificationType::kNormal, OptionTypeFlags::kNone}},
+#endif  // ROCKSDB_LITE
+};
+
+static std::unordered_map<std::string, OptionTypeInfo> enum_option_info = {
+#ifndef ROCKSDB_LITE
+    {"enum",
+     OptionTypeInfo::Enum(offsetof(struct TestOptions, e), &test_enum_map)}
+#endif
+};
+
+static std::unordered_map<std::string, OptionTypeInfo> unique_option_info = {
+#ifndef ROCKSDB_LITE
+    {"unique",
+     {0, OptionType::kConfigurable, OptionVerificationType::kNormal,
+      (OptionTypeFlags::kUnique | OptionTypeFlags::kMutable)}},
+#endif  // ROCKSDB_LITE
+};
+
+static std::unordered_map<std::string, OptionTypeInfo> shared_option_info = {
+#ifndef ROCKSDB_LITE
+    {"shared",
+     {0, OptionType::kConfigurable, OptionVerificationType::kNormal,
+      (OptionTypeFlags::kShared)}},
+#endif  // ROCKSDB_LITE
+};
+static std::unordered_map<std::string, OptionTypeInfo> pointer_option_info = {
+#ifndef ROCKSDB_LITE
+    {"pointer",
+     {0, OptionType::kConfigurable, OptionVerificationType::kNormal,
+      OptionTypeFlags::kRawPointer}},
+#endif  // ROCKSDB_LITE
+};
+
+enum TestConfigMode {
+  kEmptyMode = 0x0,            // Don't register anything
+  kMutableMode = 0x01,         // Configuration is mutable
+  kSimpleMode = 0x02,          // Use the simple options
+  kEnumMode = 0x04,            // Use the enum options
+  kDefaultMode = kSimpleMode,  // Use no inner nested configurations
+  kSharedMode = 0x10,          // Use shared configuration
+  kUniqueMode = 0x20,          // Use unique configuration
+  kRawPtrMode = 0x40,          // Use pointer configuration
+  kNestedMode = (kSharedMode | kUniqueMode | kRawPtrMode),
+  kAllOptMode = (kNestedMode | kEnumMode | kSimpleMode),
+};
+
+template <typename T>
+class TestConfigurable : public Configurable {
+ protected:
+  std::string name_;
+  std::string prefix_;
+  TestOptions options_;
+
+ public:
+  std::unique_ptr<T> unique_;
+  std::shared_ptr<T> shared_;
+  T* pointer_;
+
+  TestConfigurable(const std::string& name, int mode,
+                   const std::unordered_map<std::string, OptionTypeInfo>* map =
+                       &simple_option_info)
+      : name_(name), pointer_(nullptr) {
+    prefix_ = "test." + name + ".";
+    if ((mode & TestConfigMode::kSimpleMode) != 0) {
+      ConfigurableHelper::RegisterOptions(*this, name_, &options_, map);
+    }
+    if ((mode & TestConfigMode::kEnumMode) != 0) {
+      ConfigurableHelper::RegisterOptions(*this, name_ + "Enum", &options_,
+                                          &enum_option_info);
+    }
+  }
+
+  ~TestConfigurable() override { delete pointer_; }
+};
+
+}  // namespace test
+}  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/options/customizable.cc

@@ -0,0 +1,77 @@
+// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
+
+#include "rocksdb/customizable.h"
+
+#include "options/configurable_helper.h"
+#include "rocksdb/convenience.h"
+#include "rocksdb/status.h"
+#include "util/string_util.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+std::string Customizable::GetOptionName(const std::string& long_name) const {
+  const std::string& name = Name();
+  size_t name_len = name.size();
+  if (long_name.size() > name_len + 1 &&
+      long_name.compare(0, name_len, name) == 0 &&
+      long_name.at(name_len) == '.') {
+    return long_name.substr(name_len + 1);
+  } else {
+    return Configurable::GetOptionName(long_name);
+  }
+}
+
+#ifndef ROCKSDB_LITE
+Status Customizable::GetOption(const ConfigOptions& config_options,
+                               const std::string& opt_name,
+                               std::string* value) const {
+  if (opt_name == ConfigurableHelper::kIdPropName) {
+    *value = GetId();
+    return Status::OK();
+  } else {
+    return Configurable::GetOption(config_options, opt_name, value);
+  }
+}
+
+std::string Customizable::SerializeOptions(const ConfigOptions& config_options,
+                                           const std::string& prefix) const {
+  std::string result;
+  std::string parent;
+  if (!config_options.IsShallow()) {
+    parent = Configurable::SerializeOptions(config_options, "");
+  }
+  if (parent.empty()) {
+    result = GetId();
+  } else {
+    result.append(prefix + ConfigurableHelper::kIdPropName + "=" + GetId() +
+                  config_options.delimiter);
+    result.append(parent);
+  }
+  return result;
+}
+
+#endif  // ROCKSDB_LITE
+
+bool Customizable::AreEquivalent(const ConfigOptions& config_options,
+                                 const Configurable* other,
+                                 std::string* mismatch) const {
+  if (config_options.sanity_level > ConfigOptions::kSanityLevelNone &&
+      this != other) {
+    const Customizable* custom = reinterpret_cast<const Customizable*>(other);
+    if (GetId() != custom->GetId()) {
+      *mismatch = ConfigurableHelper::kIdPropName;
+      return false;
+    } else if (config_options.sanity_level >
+               ConfigOptions::kSanityLevelLooselyCompatible) {
+      bool matches =
+          Configurable::AreEquivalent(config_options, other, mismatch);
+      return matches;
+    }
+  }
+  return true;
+}
+
+}  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/options/customizable_helper.h

@@ -0,0 +1,216 @@
+// Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
+
+#pragma once
+#include <functional>
+#include <memory>
+#include <unordered_map>
+
+#include "options/configurable_helper.h"
+#include "options/options_helper.h"
+#include "rocksdb/convenience.h"
+#include "rocksdb/customizable.h"
+#include "rocksdb/status.h"
+#include "rocksdb/utilities/object_registry.h"
+
+namespace ROCKSDB_NAMESPACE {
+template <typename T>
+using SharedFactoryFunc =
+    std::function<bool(const std::string&, std::shared_ptr<T>*)>;
+
+template <typename T>
+using UniqueFactoryFunc =
+    std::function<bool(const std::string&, std::unique_ptr<T>*)>;
+
+template <typename T>
+using StaticFactoryFunc = std::function<bool(const std::string&, T**)>;
+
+// Creates a new shared Customizable object based on the input parameters.
+// This method parses the input value to determine the type of instance to
+// create. If there is an existing instance (in result) and it is the same type
+// as the object being created, the existing configuration is stored and used as
+// the default for the new object.
+//
+// The value parameter specified the instance class of the object to create.
+// If it is a simple string (e.g. BlockBasedTable), then the instance will be
+// created using the default settings.  If the value is a set of name-value
+// pairs, then the "id" value is used to determine the instance to create and
+// the remaining parameters are used to configure the object.  Id name-value
+// pairs are specified, there must be an "id=value" pairing or an error will
+// result.
+//
+// The config_options parameter controls the process and how errors are
+// returned. If ignore_unknown_options=true, unknown values are ignored during
+// the configuration If ignore_unsupported_options=true, unknown instance types
+// are ignored If invoke_prepare_options=true, the resulting instance wll be
+// initialized (via PrepareOptions
+//
+// @param config_options Controls how the instance is created and errors are
+// handled
+// @param value Either the simple name of the instance to create, or a set of
+// name-value pairs to
+//              create and initailzie the object
+// @param func  Optional function to call to attempt to create an instance
+// @param result The newly created instance.
+template <typename T>
+static Status LoadSharedObject(const ConfigOptions& config_options,
+                               const std::string& value,
+                               const SharedFactoryFunc<T>& func,
+                               std::shared_ptr<T>* result) {
+  std::string id;
+  std::unordered_map<std::string, std::string> opt_map;
+  Status status = ConfigurableHelper::GetOptionsMap(value, &id, &opt_map);
+  if (!status.ok()) {  // GetOptionsMap failed
+    return status;
+  }
+  std::string curr_opts;
+#ifndef ROCKSDB_LITE
+  if (result->get() != nullptr && result->get()->GetId() == id) {
+    // Try to get the existing options, ignoring any errors
+    ConfigOptions embedded = config_options;
+    embedded.delimiter = ";";
+    result->get()->GetOptionString(embedded, &curr_opts).PermitUncheckedError();
+  }
+#endif
+  if (func == nullptr || !func(id, result)) {  // No factory, or it failed
+    if (id.empty() && opt_map.empty()) {
+      // No Id and no options.  Clear the object
+      result->reset();
+      return Status::OK();
+    } else if (id.empty()) {  // We have no Id but have options.  Not good
+      return Status::NotSupported("Cannot reset object ", id);
+    } else {
+#ifndef ROCKSDB_LITE
+      status = ObjectRegistry::NewInstance()->NewSharedObject(id, result);
+#else
+      status = Status::NotSupported("Cannot load object in LITE mode ", id);
+#endif
+      if (!status.ok()) {
+        if (config_options.ignore_unsupported_options) {
+          return Status::OK();
+        } else {
+          return status;
+        }
+      }
+    }
+  }
+  return ConfigurableHelper::ConfigureNewObject(config_options, result->get(),
+                                                id, curr_opts, opt_map);
+}
+
+// Creates a new unique customizable instance object based on the input
+// parameters.
+// @see LoadSharedObject for more information on the inner workings of this
+// method.
+//
+// @param config_options Controls how the instance is created and errors are
+// handled
+// @param value Either the simple name of the instance to create, or a set of
+// name-value pairs to
+//              create and initailzie the object
+// @param func  Optional function to call to attempt to create an instance
+// @param result The newly created instance.
+template <typename T>
+static Status LoadUniqueObject(const ConfigOptions& config_options,
+                               const std::string& value,
+                               const UniqueFactoryFunc<T>& func,
+                               std::unique_ptr<T>* result) {
+  std::string id;
+  std::unordered_map<std::string, std::string> opt_map;
+  Status status = ConfigurableHelper::GetOptionsMap(value, &id, &opt_map);
+  if (!status.ok()) {  // GetOptionsMap failed
+    return status;
+  }
+  std::string curr_opts;
+#ifndef ROCKSDB_LITE
+  if (result->get() != nullptr && result->get()->GetId() == id) {
+    // Try to get the existing options, ignoring any errors
+    ConfigOptions embedded = config_options;
+    embedded.delimiter = ";";
+    result->get()->GetOptionString(embedded, &curr_opts).PermitUncheckedError();
+  }
+#endif
+  if (func == nullptr || !func(id, result)) {  // No factory, or it failed
+    if (id.empty() && opt_map.empty()) {
+      // No Id and no options.  Clear the object
+      result->reset();
+      return Status::OK();
+    } else if (id.empty()) {  // We have no Id but have options.  Not good
+      return Status::NotSupported("Cannot reset object ", id);
+    } else {
+#ifndef ROCKSDB_LITE
+      status = ObjectRegistry::NewInstance()->NewUniqueObject(id, result);
+#else
+      status = Status::NotSupported("Cannot load object in LITE mode ", id);
+#endif  // ROCKSDB_LITE
+      if (!status.ok()) {
+        if (config_options.ignore_unsupported_options) {
+          return Status::OK();
+        } else {
+          return status;
+        }
+      }
+    }
+  }
+  return ConfigurableHelper::ConfigureNewObject(config_options, result->get(),
+                                                id, curr_opts, opt_map);
+}
+// Creates a new static (raw pointer) customizable instance object based on the
+// input parameters.
+// @see LoadSharedObject for more information on the inner workings of this
+// method.
+//
+// @param config_options Controls how the instance is created and errors are
+// handled
+// @param value Either the simple name of the instance to create, or a set of
+// name-value pairs to
+//              create and initailzie the object
+// @param func  Optional function to call to attempt to create an instance
+// @param result The newly created instance.
+template <typename T>
+static Status LoadStaticObject(const ConfigOptions& config_options,
+                               const std::string& value,
+                               const StaticFactoryFunc<T>& func, T** result) {
+  std::string id;
+  std::unordered_map<std::string, std::string> opt_map;
+  Status status = ConfigurableHelper::GetOptionsMap(value, &id, &opt_map);
+  if (!status.ok()) {  // GetOptionsMap failed
+    return status;
+  }
+  std::string curr_opts;
+#ifndef ROCKSDB_LITE
+  if (*result != nullptr && (*result)->GetId() == id) {
+    // Try to get the existing options, ignoring any errors
+    ConfigOptions embedded = config_options;
+    embedded.delimiter = ";";
+    (*result)->GetOptionString(embedded, &curr_opts).PermitUncheckedError();
+  }
+#endif
+  if (func == nullptr || !func(id, result)) {  // No factory, or it failed
+    if (id.empty() && opt_map.empty()) {
+      // No Id and no options.  Clear the object
+      *result = nullptr;
+      return Status::OK();
+    } else if (id.empty()) {  // We have no Id but have options.  Not good
+      return Status::NotSupported("Cannot reset object ", id);
+    } else {
+#ifndef ROCKSDB_LITE
+      status = ObjectRegistry::NewInstance()->NewStaticObject(id, result);
+#else
+      status = Status::NotSupported("Cannot load object in LITE mode ", id);
+#endif  // ROCKSDB_LITE
+      if (!status.ok()) {
+        if (config_options.ignore_unsupported_options) {
+          return Status::OK();
+        } else {
+          return status;
+        }
+      }
+    }
+  }
+  return ConfigurableHelper::ConfigureNewObject(config_options, *result, id,
+                                                curr_opts, opt_map);
+}
+}  // namespace ROCKSDB_NAMESPACE