@nxtedition/rocksdb 8.1.7 → 8.1.8

package/deps/rocksdb/rocksdb/include/rocksdb/convenience.h

@@ -90,10 +90,8 @@ struct ConfigOptions {
   // The environment to use for this option
   Env* env = Env::Default();
 
-#ifndef ROCKSDB_LITE
   // The object registry to use for this options
   std::shared_ptr<ObjectRegistry> registry;
-#endif
 
   bool IsShallow() const { return depth == Depth::kDepthShallow; }
   bool IsDetailed() const { return depth == Depth::kDepthDetailed; }
@@ -107,7 +105,6 @@ struct ConfigOptions {
   }
 };
 
-#ifndef ROCKSDB_LITE
 
 // The following set of functions provide a way to construct RocksDB Options
 // from a string or a string-to-string map.  Here is the general rule of
@@ -163,9 +160,10 @@ struct ConfigOptions {
 //     "kCompactionStyleNone".
 //
 
-// Take a default ColumnFamilyOptions "base_options" in addition to a
-// map "opts_map" of option name to option value to construct the new
-// ColumnFamilyOptions "new_options".
+// Take a ConfigOptions `config_options` and a ColumnFamilyOptions
+// "base_options" as the default option in addition to a map "opts_map" of
+// option name to option value to construct the new ColumnFamilyOptions
+// "new_options".
 //
 // Below are the instructions of how to config some non-primitive-typed
 // options in ColumnFamilyOptions:
@@ -241,11 +239,6 @@ struct ConfigOptions {
 //        cf_opt.compression_opts.strategy = 6;
 //        cf_opt.compression_opts.max_dict_bytes = 7;
 //
-// The GetColumnFamilyOptionsFromMap(ConfigOptions, ...) should be used; the
-// alternative signature may be deprecated in a future release.  The equivalent
-// functionality can be achieved by setting the corresponding options in
-// the ConfigOptions parameter.
-//
 // @param config_options controls how the map is processed.
 // @param base_options the default options of the output "new_options".
 // @param opts_map an option name to value map for specifying how "new_options"
@@ -270,15 +263,10 @@ Status GetColumnFamilyOptionsFromMap(
     const ColumnFamilyOptions& base_options,
     const std::unordered_map<std::string, std::string>& opts_map,
     ColumnFamilyOptions* new_options);
-Status GetColumnFamilyOptionsFromMap(
-    const ColumnFamilyOptions& base_options,
-    const std::unordered_map<std::string, std::string>& opts_map,
-    ColumnFamilyOptions* new_options, bool input_strings_escaped = false,
-    bool ignore_unknown_options = false);
 
-// Take a default DBOptions "base_options" in addition to a
-// map "opts_map" of option name to option value to construct the new
-// DBOptions "new_options".
+// Take a ConfigOptions `config_options` and a DBOptions "base_options" as the
+// default option in addition to a map "opts_map" of option name to option value
+// to construct the new DBOptions "new_options".
 //
 // Below are the instructions of how to config some non-primitive-typed
 // options in DBOptions:
@@ -289,11 +277,6 @@ Status GetColumnFamilyOptionsFromMap(
 //   - Passing {"rate_limiter_bytes_per_sec", "1024"} is equivalent to
 //     passing NewGenericRateLimiter(1024) to rate_limiter_bytes_per_sec.
 //
-// The GetDBOptionsFromMap(ConfigOptions, ...) should be used; the
-// alternative signature may be deprecated in a future release. The equivalent
-// functionality can be achieved by setting the corresponding options in
-// the ConfigOptions parameter.
-//
 // @param config_options controls how the map is processed.
 // @param base_options the default options of the output "new_options".
 // @param opts_map an option name to value map for specifying how "new_options"
@@ -317,15 +300,11 @@ Status GetDBOptionsFromMap(
     const ConfigOptions& cfg_options, const DBOptions& base_options,
     const std::unordered_map<std::string, std::string>& opts_map,
     DBOptions* new_options);
-Status GetDBOptionsFromMap(
-    const DBOptions& base_options,
-    const std::unordered_map<std::string, std::string>& opts_map,
-    DBOptions* new_options, bool input_strings_escaped = false,
-    bool ignore_unknown_options = false);
 
-// Take a default BlockBasedTableOptions "table_options" in addition to a
-// map "opts_map" of option name to option value to construct the new
-// BlockBasedTableOptions "new_table_options".
+// Take a ConfigOptions `config_options` and a BlockBasedTableOptions
+// "table_options" as the default option in addition to a map "opts_map" of
+// option name to option value to construct the new BlockBasedTableOptions
+// "new_table_options".
 //
 // Below are the instructions of how to config some non-primitive-typed
 // options in BlockBasedTableOptions:
@@ -348,11 +327,6 @@ Status GetDBOptionsFromMap(
 //   - Passing {"block_cache", "1M"} in GetBlockBasedTableOptionsFromMap is
 //     equivalent to setting block_cache using NewLRUCache(1024 * 1024).
 //
-// The GetBlockBasedTableOptionsFromMap(ConfigOptions, ...) should be used;
-// the alternative signature may be deprecated in a future release. The
-// equivalent functionality can be achieved by setting the corresponding
-// options in the ConfigOptions parameter.
-//
 // @param config_options controls how the map is processed.
 // @param table_options the default options of the output "new_table_options".
 // @param opts_map an option name to value map for specifying how
@@ -372,20 +346,11 @@ Status GetBlockBasedTableOptionsFromMap(
     const BlockBasedTableOptions& table_options,
     const std::unordered_map<std::string, std::string>& opts_map,
     BlockBasedTableOptions* new_table_options);
-Status GetBlockBasedTableOptionsFromMap(
-    const BlockBasedTableOptions& table_options,
-    const std::unordered_map<std::string, std::string>& opts_map,
-    BlockBasedTableOptions* new_table_options,
-    bool input_strings_escaped = false, bool ignore_unknown_options = false);
 
-// Take a default PlainTableOptions "table_options" in addition to a
-// map "opts_map" of option name to option value to construct the new
-// PlainTableOptions "new_table_options".
-//
-// The GetPlainTableOptionsFromMap(ConfigOptions, ...) should be used; the
-// alternative signature may be deprecated in a future release. The equivalent
-// functionality can be achieved by setting the corresponding options in
-// the ConfigOptions parameter.
+// Take a ConfigOptions `config_options` and a default PlainTableOptions
+// "table_options" as the default option in addition to a map "opts_map" of
+// option name to option value to construct the new PlainTableOptions
+// "new_table_options".
 //
 // @param config_options controls how the map is processed.
 // @param table_options the default options of the output "new_table_options".
@@ -405,43 +370,26 @@ Status GetPlainTableOptionsFromMap(
     const ConfigOptions& config_options, const PlainTableOptions& table_options,
     const std::unordered_map<std::string, std::string>& opts_map,
     PlainTableOptions* new_table_options);
-Status GetPlainTableOptionsFromMap(
-    const PlainTableOptions& table_options,
-    const std::unordered_map<std::string, std::string>& opts_map,
-    PlainTableOptions* new_table_options, bool input_strings_escaped = false,
-    bool ignore_unknown_options = false);
 
-// Take a string representation of option names and values, apply them into the
-// base_options, and return the new options as a result. The string has the
-// following format:
+// Take a ConfigOptions `config_options`, a string representation of option
+// names and values, apply them into the base_options, and return the new
+// options as a result. The string has the following format:
 //   "write_buffer_size=1024;max_write_buffer_number=2"
 // Nested options config is also possible. For example, you can define
 // BlockBasedTableOptions as part of the string for block-based table factory:
 //   "write_buffer_size=1024;block_based_table_factory={block_size=4k};"
 //   "max_write_buffer_num=2"
 //
-//
-// The GetColumnFamilyOptionsFromString(ConfigOptions, ...) should be used; the
-// alternative signature may be deprecated in a future release. The equivalent
-// functionality can be achieved by setting the corresponding options in
-// the ConfigOptions parameter.
 Status GetColumnFamilyOptionsFromString(const ConfigOptions& config_options,
                                         const ColumnFamilyOptions& base_options,
                                         const std::string& opts_str,
                                         ColumnFamilyOptions* new_options);
-Status GetColumnFamilyOptionsFromString(const ColumnFamilyOptions& base_options,
-                                        const std::string& opts_str,
-                                        ColumnFamilyOptions* new_options);
 
 Status GetDBOptionsFromString(const ConfigOptions& config_options,
                               const DBOptions& base_options,
                               const std::string& opts_str,
                               DBOptions* new_options);
 
-Status GetDBOptionsFromString(const DBOptions& base_options,
-                              const std::string& opts_str,
-                              DBOptions* new_options);
-
 Status GetStringFromDBOptions(const ConfigOptions& config_options,
                               const DBOptions& db_options,
                               std::string* opts_str);
@@ -461,17 +409,11 @@ Status GetStringFromCompressionType(std::string* compression_str,
 
 std::vector<CompressionType> GetSupportedCompressions();
 
-Status GetBlockBasedTableOptionsFromString(
-    const BlockBasedTableOptions& table_options, const std::string& opts_str,
-    BlockBasedTableOptions* new_table_options);
 Status GetBlockBasedTableOptionsFromString(
     const ConfigOptions& config_options,
     const BlockBasedTableOptions& table_options, const std::string& opts_str,
     BlockBasedTableOptions* new_table_options);
 
-Status GetPlainTableOptionsFromString(const PlainTableOptions& table_options,
-                                      const std::string& opts_str,
-                                      PlainTableOptions* new_table_options);
 Status GetPlainTableOptionsFromString(const ConfigOptions& config_options,
                                       const PlainTableOptions& table_options,
                                       const std::string& opts_str,
@@ -520,6 +462,5 @@ Status VerifySstFileChecksum(const Options& options,
                              const ReadOptions& read_options,
                              const std::string& file_path,
                              const SequenceNumber& largest_seqno = 0);
-#endif  // ROCKSDB_LITE
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/include/rocksdb/customizable.h

@@ -157,12 +157,10 @@ class Customizable : public Configurable {
   bool AreEquivalent(const ConfigOptions& config_options,
                      const Configurable* other,
                      std::string* mismatch) const override;
-#ifndef ROCKSDB_LITE
   // Gets the value of the option associated with the input name
   // @see Configurable::GetOption for more details
   Status GetOption(const ConfigOptions& config_options, const std::string& name,
                    std::string* value) const override;
-#endif  // ROCKSDB_LITE
   // Helper method for getting for parsing the opt_value into the corresponding
   // options for use in potentially creating a new Customizable object (this
   // method is primarily a support method for LoadSharedObject et al for new
@@ -224,10 +222,8 @@ class Customizable : public Configurable {
   virtual const char* NickName() const { return ""; }
   //  Given a name (e.g. rocksdb.my.type.opt), returns the short name (opt)
   std::string GetOptionName(const std::string& long_name) const override;
-#ifndef ROCKSDB_LITE
   std::string SerializeOptions(const ConfigOptions& options,
                                const std::string& prefix) const override;
-#endif  // ROCKSDB_LITE
 };
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/include/rocksdb/data_structure.h

@@ -15,37 +15,172 @@
 
 namespace ROCKSDB_NAMESPACE {
 
-// This is a data structure specifically designed as a "Set" for a
-// pretty small scale of Enum structure. For now, it can support up
-// to 64 element, and it is expandable in the future.
-template <typename ENUM_TYPE, ENUM_TYPE MAX_VALUE>
+namespace detail {
+int CountTrailingZeroBitsForSmallEnumSet(uint64_t);
+}  // namespace detail
+
+// Represents a set of values of some enum type with a small number of
+// possible enumerators. For now, it supports enums where no enumerator
+// exceeds 63 when converted to int.
+template <typename ENUM_TYPE, ENUM_TYPE MAX_ENUMERATOR>
 class SmallEnumSet {
+ private:
+  using StateT = uint64_t;
+  static constexpr int kStateBits = sizeof(StateT) * 8;
+  static constexpr int kMaxMax = kStateBits - 1;
+  static constexpr int kMaxValue = static_cast<int>(MAX_ENUMERATOR);
+  static_assert(kMaxValue >= 0);
+  static_assert(kMaxValue <= kMaxMax);
+
  public:
+  // construct / create
   SmallEnumSet() : state_(0) {}
 
-  ~SmallEnumSet() {}
+  template <class... TRest>
+  /*implicit*/ constexpr SmallEnumSet(const ENUM_TYPE e, TRest... rest) {
+    *this = SmallEnumSet(rest...).With(e);
+  }
 
-  // Return true if the input enum is included in the "Set" (i.e., changes the
-  // internal scalar state successfully), otherwise, it will return false.
-  bool Add(const ENUM_TYPE value) {
-    static_assert(MAX_VALUE <= 63, "Size currently limited to 64");
-    assert(value >= 0 && value <= MAX_VALUE);
-    uint64_t old_state = state_;
-    uint64_t tmp = 1;
-    state_ |= (tmp << value);
-    return old_state != state_;
+  // Return the set that includes all valid values, assuming the enum
+  // is "dense" (includes all values converting to 0 through kMaxValue)
+  static constexpr SmallEnumSet All() {
+    StateT tmp = StateT{1} << kMaxValue;
+    return SmallEnumSet(RawStateMarker(), tmp | (tmp - 1));
   }
 
+  // equality
+  bool operator==(const SmallEnumSet& that) const {
+    return this->state_ == that.state_;
+  }
+  bool operator!=(const SmallEnumSet& that) const { return !(*this == that); }
+
+  // query
+
   // Return true if the input enum is contained in the "Set".
-  bool Contains(const ENUM_TYPE value) {
-    static_assert(MAX_VALUE <= 63, "Size currently limited to 64");
-    assert(value >= 0 && value <= MAX_VALUE);
-    uint64_t tmp = 1;
+  bool Contains(const ENUM_TYPE e) const {
+    int value = static_cast<int>(e);
+    assert(value >= 0 && value <= kMaxValue);
+    StateT tmp = 1;
     return state_ & (tmp << value);
   }
 
+  bool empty() const { return state_ == 0; }
+
+  // iterator
+  class const_iterator {
+   public:
+    // copy
+    const_iterator(const const_iterator& that) = default;
+    const_iterator& operator=(const const_iterator& that) = default;
+
+    // move
+    const_iterator(const_iterator&& that) noexcept = default;
+    const_iterator& operator=(const_iterator&& that) noexcept = default;
+
+    // equality
+    bool operator==(const const_iterator& that) const {
+      assert(set_ == that.set_);
+      return this->pos_ == that.pos_;
+    }
+
+    bool operator!=(const const_iterator& that) const {
+      return !(*this == that);
+    }
+
+    // ++iterator
+    const_iterator& operator++() {
+      if (pos_ < kMaxValue) {
+        pos_ = set_->SkipUnset(pos_ + 1);
+      } else {
+        pos_ = kStateBits;
+      }
+      return *this;
+    }
+
+    // iterator++
+    const_iterator operator++(int) {
+      auto old = *this;
+      ++*this;
+      return old;
+    }
+
+    ENUM_TYPE operator*() const {
+      assert(pos_ <= kMaxValue);
+      return static_cast<ENUM_TYPE>(pos_);
+    }
+
+   private:
+    friend class SmallEnumSet;
+    const_iterator(const SmallEnumSet* set, int pos) : set_(set), pos_(pos) {}
+    const SmallEnumSet* set_;
+    int pos_;
+  };
+
+  const_iterator begin() const { return const_iterator(this, SkipUnset(0)); }
+
+  const_iterator end() const { return const_iterator(this, kStateBits); }
+
+  // mutable ops
+
+  // Modifies the set (if needed) to include the given value. Returns true
+  // iff the set was modified.
+  bool Add(const ENUM_TYPE e) {
+    int value = static_cast<int>(e);
+    assert(value >= 0 && value <= kMaxValue);
+    StateT old_state = state_;
+    state_ |= (StateT{1} << value);
+    return old_state != state_;
+  }
+
+  // Modifies the set (if needed) not to include the given value. Returns true
+  // iff the set was modified.
+  bool Remove(const ENUM_TYPE e) {
+    int value = static_cast<int>(e);
+    assert(value >= 0 && value <= kMaxValue);
+    StateT old_state = state_;
+    state_ &= ~(StateT{1} << value);
+    return old_state != state_;
+  }
+
+  // applicative ops
+
+  // Return a new set based on this one with the additional value(s) inserted
+  constexpr SmallEnumSet With(const ENUM_TYPE e) const {
+    int value = static_cast<int>(e);
+    assert(value >= 0 && value <= kMaxValue);
+    return SmallEnumSet(RawStateMarker(), state_ | (StateT{1} << value));
+  }
+  template <class... TRest>
+  constexpr SmallEnumSet With(const ENUM_TYPE e1, const ENUM_TYPE e2,
+                              TRest... rest) const {
+    return With(e1).With(e2, rest...);
+  }
+
+  // Return a new set based on this one excluding the given value(s)
+  constexpr SmallEnumSet Without(const ENUM_TYPE e) const {
+    int value = static_cast<int>(e);
+    assert(value >= 0 && value <= kMaxValue);
+    return SmallEnumSet(RawStateMarker(), state_ & ~(StateT{1} << value));
+  }
+  template <class... TRest>
+  constexpr SmallEnumSet Without(const ENUM_TYPE e1, const ENUM_TYPE e2,
+                                 TRest... rest) const {
+    return Without(e1).Without(e2, rest...);
+  }
+
  private:
-  uint64_t state_;
+  int SkipUnset(int pos) const {
+    StateT tmp = state_ >> pos;
+    if (tmp == 0) {
+      return kStateBits;
+    } else {
+      return pos + detail::CountTrailingZeroBitsForSmallEnumSet(tmp);
+    }
+  }
+  struct RawStateMarker {};
+  explicit SmallEnumSet(RawStateMarker, StateT state) : state_(state) {}
+
+  StateT state_;
 };
 
 }  // namespace ROCKSDB_NAMESPACE