Replace most typedef with using= (#8751)

Summary:
Old typedef syntax is confusing

Most but not all changes with

    perl -pi -e 's/typedef (.*) ([a-zA-Z0-9_]+);/using $2 = $1;/g' list_of_files
    make format

Pull Request resolved: https://github.com/facebook/rocksdb/pull/8751

Test Plan: existing

Reviewed By: zhichao-cao

Differential Revision: D30745277

Pulled By: pdillinger

fbshipit-source-id: 6f65f0631c3563382d43347896020413cc2366d9

cache/clock_cache.cc

@@ -260,7 +260,7 @@ struct CleanupContext {
 class ClockCacheShard final : public CacheShard {
  public:
   // Hash map type.
-  typedef tbb::concurrent_hash_map<CacheKey, CacheHandle*, CacheKey> HashTable;
+  using HashTable = tbb::concurrent_hash_map<CacheKey, CacheHandle*, CacheKey>;
 
   ClockCacheShard();
   ~ClockCacheShard() override;

db/compaction/compaction_picker_universal.cc

@@ -157,9 +157,9 @@ struct SmallestKeyHeapComparator {
   const Comparator* ucmp_;
 };
 
-typedef std::priority_queue<InputFileInfo, std::vector<InputFileInfo>,
+using SmallestKeyHeap =
-                            SmallestKeyHeapComparator>
+    std::priority_queue<InputFileInfo, std::vector<InputFileInfo>,
-    SmallestKeyHeap;
+                        SmallestKeyHeapComparator>;
 
 // This function creates the heap that is used to find if the files are
 // overlapping during universal compaction when the allow_trivial_move

db/db_impl/db_impl.cc

@@ -3116,7 +3116,7 @@ SnapshotImpl* DBImpl::GetSnapshotImpl(bool is_write_conflict_boundary,
 }
 
 namespace {
-typedef autovector<ColumnFamilyData*, 2> CfdList;
+using CfdList = autovector<ColumnFamilyData*, 2>;
 bool CfdListContains(const CfdList& list, ColumnFamilyData* cfd) {
   for (const ColumnFamilyData* t : list) {
     if (t == cfd) {

db/db_impl/db_impl.h

@@ -1753,7 +1753,7 @@ class DBImpl : public DB {
   // specified value, this flush request is considered to have completed its
   // work of flushing this column family. After completing the work for all
   // column families in this request, this flush is considered complete.
-  typedef std::vector<std::pair<ColumnFamilyData*, uint64_t>> FlushRequest;
+  using FlushRequest = std::vector<std::pair<ColumnFamilyData*, uint64_t>>;
 
   void GenerateFlushRequest(const autovector<ColumnFamilyData*>& cfds,
                             FlushRequest* req);

db/db_test.cc

@@ -2812,7 +2812,7 @@ TEST_F(DBTest, GroupCommitTest) {
 #endif  // TRAVIS
 
 namespace {
-typedef std::map<std::string, std::string> KVMap;
+using KVMap = std::map<std::string, std::string>;
 }
 
 class ModelDB : public DB {

db/forward_iterator.h

@@ -39,8 +39,9 @@ class MinIterComparator {
   const Comparator* comparator_;
 };
 
-typedef std::priority_queue<InternalIterator*, std::vector<InternalIterator*>,
+using MinIterHeap =
-                            MinIterComparator> MinIterHeap;
+    std::priority_queue<InternalIterator*, std::vector<InternalIterator*>,
+                        MinIterComparator>;
 
 /**
  * ForwardIterator is a special type of iterator that only supports Seek()

db/kv_checksum.h

@@ -49,10 +49,10 @@ template <typename T>
 class ProtectionInfoKVOTS;
 
 // Aliases for 64-bit protection infos.
-typedef ProtectionInfo<uint64_t> ProtectionInfo64;
+using ProtectionInfo64 = ProtectionInfo<uint64_t>;
-typedef ProtectionInfoKVOT<uint64_t> ProtectionInfoKVOT64;
+using ProtectionInfoKVOT64 = ProtectionInfoKVOT<uint64_t>;
-typedef ProtectionInfoKVOTC<uint64_t> ProtectionInfoKVOTC64;
+using ProtectionInfoKVOTC64 = ProtectionInfoKVOTC<uint64_t>;
-typedef ProtectionInfoKVOTS<uint64_t> ProtectionInfoKVOTS64;
+using ProtectionInfoKVOTS64 = ProtectionInfoKVOTS<uint64_t>;
 
 template <typename T>
 class ProtectionInfo {

db/malloc_stats.cc

@@ -19,10 +19,10 @@ namespace ROCKSDB_NAMESPACE {
 
 #ifdef ROCKSDB_JEMALLOC
 
-typedef struct {
+struct MallocStatus {
   char* cur;
   char* end;
-} MallocStatus;
+};
 
 static void GetJemallocStatus(void* mstat_arg, const char* status) {
   MallocStatus* mstat = reinterpret_cast<MallocStatus*>(mstat_arg);

db/pinned_iterators_manager.h

@@ -43,7 +43,7 @@ class PinnedIteratorsManager : public Cleanable {
     }
   }
 
-  typedef void (*ReleaseFunction)(void* arg1);
+  using ReleaseFunction = void (*)(void* arg1);
   void PinPtr(void* ptr, ReleaseFunction release_func) {
     assert(pinning_enabled);
     if (ptr == nullptr) {

env/env_basic_test.cc

@@ -17,8 +17,9 @@
 #include "test_util/testharness.h"
 
 namespace ROCKSDB_NAMESPACE {
-typedef Env* CreateEnvFunc();
 namespace {
+using CreateEnvFunc = Env*();
+
 // These functions are used to create the various environments under which this
 // test can execute. These functions are used to allow the test cases to be
 // created without the Env being initialized, thereby eliminating a potential

include/rocksdb/advanced_options.h

@@ -650,8 +650,8 @@ struct AdvancedColumnFamilyOptions {
   // the tables.
   // Default: empty vector -- no user-defined statistics collection will be
   // performed.
-  typedef std::vector<std::shared_ptr<TablePropertiesCollectorFactory>>
+  using TablePropertiesCollectorFactories =
-      TablePropertiesCollectorFactories;
+      std::vector<std::shared_ptr<TablePropertiesCollectorFactory>>;
   TablePropertiesCollectorFactories table_properties_collector_factories;
 
   // Maximum number of successive merge operations on a key in the memtable.

include/rocksdb/cache.h

@@ -202,9 +202,6 @@ class Cache {
   // takes in a buffer from the NVM cache and constructs an object using
   // it. The callback doesn't have ownership of the buffer and should
   // copy the contents into its own buffer.
-  // typedef std::function<Status(void* buf, size_t size, void** out_obj,
-  //                             size_t* charge)>
-  //    CreateCallback;
   using CreateCallback = std::function<Status(void* buf, size_t size,
                                               void** out_obj, size_t* charge)>;
 

include/rocksdb/cleanable.h

@@ -30,7 +30,7 @@ class Cleanable {
   //
   // Note that unlike all of the preceding methods, this method is
   // not abstract and therefore clients should not override it.
-  typedef void (*CleanupFunction)(void* arg1, void* arg2);
+  using CleanupFunction = void (*)(void* arg1, void* arg2);
   void RegisterCleanup(CleanupFunction function, void* arg1, void* arg2);
   void DelegateCleanupsTo(Cleanable* other);
   // DoCleanup and also resets the pointers for reuse

include/rocksdb/db.h

@@ -136,8 +136,8 @@ struct GetMergeOperandsOptions {
 // A collections of table properties objects, where
 //  key: is the table's file name.
 //  value: the table properties object of the given table.
-typedef std::unordered_map<std::string, std::shared_ptr<const TableProperties>>
+using TablePropertiesCollection =
-    TablePropertiesCollection;
+    std::unordered_map<std::string, std::shared_ptr<const TableProperties>>;
 
 // A DB is a persistent, versioned ordered map from keys to values.
 // A DB is safe for concurrent access from multiple threads without

include/rocksdb/listener.h

@@ -21,8 +21,8 @@
 
 namespace ROCKSDB_NAMESPACE {
 
-typedef std::unordered_map<std::string, std::shared_ptr<const TableProperties>>
+using TablePropertiesCollection =
-    TablePropertiesCollection;
+    std::unordered_map<std::string, std::shared_ptr<const TableProperties>>;
 
 class DB;
 class ColumnFamilyHandle;

include/rocksdb/memtablerep.h

@@ -51,7 +51,7 @@ class LookupKey;
 class SliceTransform;
 class Logger;
 
-typedef void* KeyHandle;
+using KeyHandle = void*;
 
 extern Slice GetLengthPrefixedSlice(const char* data);
 
@@ -61,7 +61,7 @@ class MemTableRep {
   // concatenated with values.
   class KeyComparator {
    public:
-    typedef ROCKSDB_NAMESPACE::Slice DecodedType;
+    using DecodedType = ROCKSDB_NAMESPACE::Slice;
 
     virtual DecodedType decode_key(const char* key) const {
       // The format of key is frozen and can be treated as a part of the API

include/rocksdb/persistent_cache.h

@@ -24,7 +24,7 @@ namespace ROCKSDB_NAMESPACE {
 // cache interface is specifically designed for persistent read cache.
 class PersistentCache {
  public:
-  typedef std::vector<std::map<std::string, double>> StatsType;
+  using StatsType = std::vector<std::map<std::string, double>>;
 
   virtual ~PersistentCache() {}
 

include/rocksdb/table_properties.h

@@ -26,7 +26,7 @@ namespace ROCKSDB_NAMESPACE {
 //      ++pos) {
 //   ...
 // }
-typedef std::map<std::string, std::string> UserCollectedProperties;
+using UserCollectedProperties = std::map<std::string, std::string>;
 
 // table properties' human-readable names in the property block.
 struct TablePropertiesNames {

include/rocksdb/transaction_log.h

@@ -14,7 +14,7 @@
 namespace ROCKSDB_NAMESPACE {
 
 class LogFile;
-typedef std::vector<std::unique_ptr<LogFile>> VectorLogPtr;
+using VectorLogPtr = std::vector<std::unique_ptr<LogFile>>;
 
 enum WalFileType {
   /* Indicates that WAL file is in archive directory. WAL files are moved from

include/rocksdb/types.h

@@ -15,7 +15,7 @@ namespace ROCKSDB_NAMESPACE {
 using ColumnFamilyId = uint32_t;
 
 // Represents a sequence number in a WAL file.
-typedef uint64_t SequenceNumber;
+using SequenceNumber = uint64_t;
 
 const SequenceNumber kMinUnCommittedSeq = 1;  // 0 is always committed
 

include/rocksdb/utilities/backup_engine.h

@@ -285,7 +285,7 @@ struct BackupFileInfo {
   uint64_t size;
 };
 
-typedef uint32_t BackupID;
+using BackupID = uint32_t;
 
 struct BackupInfo {
   BackupID backup_id = 0U;

memory/arena.h

@@ -86,7 +86,7 @@ class Arena : public Allocator {
   // Number of bytes allocated in one block
   const size_t kBlockSize;
   // Array of new[] allocated memory blocks
-  typedef std::vector<char*> Blocks;
+  using Blocks = std::vector<char*>;
   Blocks blocks_;
 
   struct MmapInfo {

memory/memory_usage.h

@@ -14,7 +14,7 @@ namespace ROCKSDB_NAMESPACE {
 template <class Key, class Value, class Hash>
 size_t ApproximateMemoryUsage(
     const std::unordered_map<Key, Value, Hash>& umap) {
-  typedef std::unordered_map<Key, Value, Hash> Map;
+  using Map = std::unordered_map<Key, Value, Hash>;
   return sizeof(umap) +
          // Size of all items plus a next pointer for each item.
          (sizeof(typename Map::value_type) + sizeof(void*)) * umap.size() +

memtable/hash_linklist_rep.cc

@@ -22,9 +22,9 @@
 namespace ROCKSDB_NAMESPACE {
 namespace {
 
-typedef const char* Key;
+using Key = const char*;
-typedef SkipList<Key, const MemTableRep::KeyComparator&> MemtableSkipList;
+using MemtableSkipList = SkipList<Key, const MemTableRep::KeyComparator&>;
-typedef std::atomic<void*> Pointer;
+using Pointer = std::atomic<void*>;
 
 // A data structure used as the header of a link list of a hash bucket.
 struct BucketHeader {

memtable/hash_skiplist_rep.cc

@@ -46,7 +46,7 @@ class HashSkipListRep : public MemTableRep {
 
  private:
   friend class DynamicIterator;
-  typedef SkipList<const char*, const MemTableRep::KeyComparator&> Bucket;
+  using Bucket = SkipList<const char*, const MemTableRep::KeyComparator&>;
 
   size_t bucket_size_;
 

memtable/inlineskiplist_test.cc

@@ -19,7 +19,7 @@
 namespace ROCKSDB_NAMESPACE {
 
 // Our test skip list stores 8-byte unsigned integers
-typedef uint64_t Key;
+using Key = uint64_t;
 
 static const char* Encode(const uint64_t* key) {
   return reinterpret_cast<const char*>(key);
@@ -32,7 +32,7 @@ static Key Decode(const char* key) {
 }
 
 struct TestComparator {
-  typedef Key DecodedType;
+  using DecodedType = Key;
 
   static DecodedType decode_key(const char* b) {
     return Decode(b);
@@ -59,7 +59,7 @@ struct TestComparator {
   }
 };
 
-typedef InlineSkipList<TestComparator> TestInlineSkipList;
+using TestInlineSkipList = InlineSkipList<TestComparator>;
 
 class InlineSkipTest : public testing::Test {
  public:

memtable/skiplist_test.cc

@@ -17,7 +17,7 @@
 
 namespace ROCKSDB_NAMESPACE {
 
-typedef uint64_t Key;
+using Key = uint64_t;
 
 struct TestComparator {
   int operator()(const Key& a, const Key& b) const {

memtable/vectorrep.cc

@@ -98,7 +98,7 @@ class VectorRep : public MemTableRep {
 
  private:
   friend class Iterator;
-  typedef std::vector<const char*> Bucket;
+  using Bucket = std::vector<const char*>;
   std::shared_ptr<Bucket> bucket_;
   mutable port::RWMutex rwlock_;
   bool immutable_;

options/cf_options.cc

@@ -479,8 +479,8 @@ static std::unordered_map<std::string, OptionTypeInfo>
         /* not yet supported
         CompressionOptions compression_opts;
         TablePropertiesCollectorFactories table_properties_collector_factories;
-        typedef std::vector<std::shared_ptr<TablePropertiesCollectorFactory>>
+        using TablePropertiesCollectorFactories =
-            TablePropertiesCollectorFactories;
+            std::vector<std::shared_ptr<TablePropertiesCollectorFactory>>;
         UpdateStatus (*inplace_callback)(char* existing_value,
                                          uint34_t* existing_value_size,
                                          Slice delta_value,

options/options_settable_test.cc

@@ -41,7 +41,7 @@ class OptionsSettableTest : public testing::Test {
 };
 
 const char kSpecialChar = 'z';
-typedef std::vector<std::pair<size_t, size_t>> OffsetGap;
+using OffsetGap = std::vector<std::pair<size_t, size_t>>;
 
 void FillWithSpecialChar(char* start_ptr, size_t total_size,
                          const OffsetGap& excluded,

port/port_example.h

@@ -70,7 +70,7 @@ class CondVar {
 //      static void Initializer() { ... do something ...; }
 //      ...
 //      port::InitOnce(&init_control, &Initializer);
-typedef intptr_t OnceType;
+using OnceType = intptr_t;
 #define LEVELDB_ONCE_INIT 0
 extern void InitOnce(port::OnceType*, void (*initializer)());
 

port/port_posix.h

@@ -177,7 +177,7 @@ static inline void AsmVolatilePause() {
 // Returns -1 if not available on this platform
 extern int PhysicalCoreID();
 
-typedef pthread_once_t OnceType;
+using OnceType = pthread_once_t;
 #define LEVELDB_ONCE_INIT PTHREAD_ONCE_INIT
 extern void InitOnce(OnceType* once, void (*initializer)());
 

port/sys_time.h

@@ -23,10 +23,10 @@ namespace ROCKSDB_NAMESPACE {
 namespace port {
 
 // Avoid including winsock2.h for this definition
-typedef struct timeval {
+struct timeval {
   long tv_sec;
   long tv_usec;
-} timeval;
+};
 
 void gettimeofday(struct timeval* tv, struct timezone* tz);
 

port/win/env_win.cc

@@ -53,10 +53,10 @@ static const size_t kSectorSize = 512;
 
 // RAII helpers for HANDLEs
 const auto CloseHandleFunc = [](HANDLE h) { ::CloseHandle(h); };
-typedef std::unique_ptr<void, decltype(CloseHandleFunc)> UniqueCloseHandlePtr;
+using UniqueCloseHandlePtr = std::unique_ptr<void, decltype(CloseHandleFunc)>;
 
 const auto FindCloseFunc = [](HANDLE h) { ::FindClose(h); };
-typedef std::unique_ptr<void, decltype(FindCloseFunc)> UniqueFindClosePtr;
+using UniqueFindClosePtr = std::unique_ptr<void, decltype(FindCloseFunc)>;
 
 void WinthreadCall(const char* label, std::error_code result) {
   if (0 != result.value()) {

port/win/env_win.h

@@ -96,7 +96,7 @@ class WinClock : public SystemClock {
   uint64_t GetPerfCounterFrequency() const { return perf_counter_frequency_; }
 
  private:
-  typedef VOID(WINAPI* FnGetSystemTimePreciseAsFileTime)(LPFILETIME);
+  using FnGetSystemTimePreciseAsFileTime = VOID(WINAPI*)(LPFILETIME);
 
   uint64_t perf_counter_frequency_;
   uint64_t nano_seconds_per_period_;

port/win/port_win.h

@@ -47,7 +47,7 @@
 #undef DeleteFile
 
 #ifndef _SSIZE_T_DEFINED
-typedef SSIZE_T ssize_t;
+using ssize_t = SSIZE_T;
 #endif
 
 // size_t printf formatting named in the manner of C99 standard formatting
@@ -292,7 +292,7 @@ static inline void AsmVolatilePause() {
 extern int PhysicalCoreID();
 
 // For Thread Local Storage abstraction
-typedef DWORD pthread_key_t;
+using pthread_key_t = DWORD;
 
 inline int pthread_key_create(pthread_key_t* key, void (*destructor)(void*)) {
   // Not used

port/win/win_thread.h

@@ -25,11 +25,10 @@ namespace port {
 //  -- is that it dynamically allocates its internals that are automatically
 //     freed when  the thread terminates and not on the destruction of the
 //     object. This makes it difficult to control the source of memory
-//     allocation 
+//     allocation
 //  -  This implements Pimpl so we can easily replace the guts of the
 //      object in our private version if necessary.
 class WindowsThread {
-
   struct Data;
 
   std::shared_ptr<Data>  data_;
@@ -37,15 +36,14 @@ class WindowsThread {
 
   void Init(std::function<void()>&&);
 
-public:
+ public:
-
+  using native_handle_type = void*;
-  typedef void* native_handle_type;
 
   // Construct with no thread
   WindowsThread();
 
   // Template constructor
-  // 
+  //
   // This templated constructor accomplishes several things
   //
   // - Allows the class as whole to be not a template
@@ -68,17 +66,12 @@ public:
   //   dependent type that both checks the signature conformance to ensure
   //   that all of the necessary arguments are provided and allows pimpl
   //   implementation.
-  template<class Fn,
+  template <class Fn, class... Args,
-    class... Args,
+            class = typename std::enable_if<!std::is_same<
-    class = typename std::enable_if<
+                typename std::decay<Fn>::type, WindowsThread>::value>::type>
-      !std::is_same<typename std::decay<Fn>::type,
+  explicit WindowsThread(Fn&& fx, Args&&... ax) : WindowsThread() {
-                    WindowsThread>::value>::type>
-  explicit WindowsThread(Fn&& fx, Args&&... ax) :
-      WindowsThread() {
-
     // Use binder to create a single callable entity
-    auto binder = std::bind(std::forward<Fn>(fx),
+    auto binder = std::bind(std::forward<Fn>(fx), std::forward<Args>(ax)...);
-      std::forward<Args>(ax)...);
     // Use std::function to take advantage of the type erasure
     // so we can still hide implementation within pimpl
     // This also makes sure that the binder signature is compliant
@@ -87,7 +80,6 @@ public:
     Init(std::move(target));
   }
 
-
   ~WindowsThread();
 
   WindowsThread(const WindowsThread&) = delete;

table/block_based/block_based_table_builder.cc

@@ -589,11 +589,11 @@ struct BlockBasedTableBuilder::ParallelCompressionRep {
   // Use a vector of BlockRep as a buffer for a determined number
   // of BlockRep structures. All data referenced by pointers in
   // BlockRep will be freed when this vector is destructed.
-  typedef std::vector<BlockRep> BlockRepBuffer;
+  using BlockRepBuffer = std::vector<BlockRep>;
   BlockRepBuffer block_rep_buf;
   // Use a thread-safe queue for concurrent access from block
   // building thread and writer thread.
-  typedef WorkQueue<BlockRep*> BlockRepPool;
+  using BlockRepPool = WorkQueue<BlockRep*>;
   BlockRepPool block_rep_pool;
 
   // Use BlockRepSlot to keep block order in write thread.
@@ -617,7 +617,7 @@ struct BlockBasedTableBuilder::ParallelCompressionRep {
   // Compression queue will pass references to BlockRep in block_rep_buf,
   // and those references are always valid before the destruction of
   // block_rep_buf.
-  typedef WorkQueue<BlockRep*> CompressQueue;
+  using CompressQueue = WorkQueue<BlockRep*>;
   CompressQueue compress_queue;
   std::vector<port::Thread> compress_thread_pool;
 
@@ -625,7 +625,7 @@ struct BlockBasedTableBuilder::ParallelCompressionRep {
   // and those references are always valid before the corresponding
   // BlockRep::slot is destructed, which is before the destruction of
   // block_rep_buf.
-  typedef WorkQueue<BlockRepSlot*> WriteQueue;
+  using WriteQueue = WorkQueue<BlockRepSlot*>;
   WriteQueue write_queue;
   std::unique_ptr<port::Thread> write_thread;
 

table/block_based/block_based_table_reader.h

@@ -41,7 +41,7 @@ struct EnvOptions;
 struct ReadOptions;
 class GetContext;
 
-typedef std::vector<std::pair<std::string, std::string>> KVPairBlock;
+using KVPairBlock = std::vector<std::pair<std::string, std::string>>;
 
 // Reader class for BlockBasedTable format.
 // For the format of BlockBasedTable refer to

table/merging_iterator.cc

@@ -28,8 +28,8 @@
 namespace ROCKSDB_NAMESPACE {
 // Without anonymous namespace here, we fail the warning -Wmissing-prototypes
 namespace {
-typedef BinaryHeap<IteratorWrapper*, MaxIteratorComparator> MergerMaxIterHeap;
+using MergerMaxIterHeap = BinaryHeap<IteratorWrapper*, MaxIteratorComparator>;
-typedef BinaryHeap<IteratorWrapper*, MinIteratorComparator> MergerMinIterHeap;
+using MergerMinIterHeap = BinaryHeap<IteratorWrapper*, MinIteratorComparator>;
 }  // namespace
 
 const size_t kNumIterReserve = 4;

table/multiget_context.h

@@ -158,12 +158,12 @@ class MultiGetContext {
     class Iterator {
      public:
       // -- iterator traits
-      typedef Iterator self_type;
+      using self_type = Iterator;
-      typedef KeyContext value_type;
+      using value_type = KeyContext;
-      typedef KeyContext& reference;
+      using reference = KeyContext&;
-      typedef KeyContext* pointer;
+      using pointer = KeyContext*;
-      typedef int difference_type;
+      using difference_type = int;
-      typedef std::forward_iterator_tag iterator_category;
+      using iterator_category = std::forward_iterator_tag;
 
       Iterator(const Range* range, size_t idx)
           : range_(range), ctx_(range->ctx_), index_(idx) {

util/autovector.h

@@ -51,25 +51,25 @@ template <class T, size_t kSize = 8>
 class autovector {
  public:
   // General STL-style container member types.
-  typedef T value_type;
+  using value_type = T;
-  typedef typename std::vector<T>::difference_type difference_type;
+  using difference_type = typename std::vector<T>::difference_type;
-  typedef typename std::vector<T>::size_type size_type;
+  using size_type = typename std::vector<T>::size_type;
-  typedef value_type& reference;
+  using reference = value_type&;
-  typedef const value_type& const_reference;
+  using const_reference = const value_type&;
-  typedef value_type* pointer;
+  using pointer = value_type*;
-  typedef const value_type* const_pointer;
+  using const_pointer = const value_type*;
 
   // This class is the base for regular/const iterator
   template <class TAutoVector, class TValueType>
   class iterator_impl {
    public:
     // -- iterator traits
-    typedef iterator_impl<TAutoVector, TValueType> self_type;
+    using self_type = iterator_impl<TAutoVector, TValueType>;
-    typedef TValueType value_type;
+    using value_type = TValueType;
-    typedef TValueType& reference;
+    using reference = TValueType&;
-    typedef TValueType* pointer;
+    using pointer = TValueType*;
-    typedef typename TAutoVector::difference_type difference_type;
+    using difference_type = typename TAutoVector::difference_type;
-    typedef std::random_access_iterator_tag iterator_category;
+    using iterator_category = std::random_access_iterator_tag;
 
     iterator_impl(TAutoVector* vect, size_t index)
         : vect_(vect), index_(index) {};
@@ -175,10 +175,10 @@ class autovector {
     size_t index_ = 0;
   };
 
-  typedef iterator_impl<autovector, value_type> iterator;
+  using iterator = iterator_impl<autovector, value_type>;
-  typedef iterator_impl<const autovector, const value_type> const_iterator;
+  using const_iterator = iterator_impl<const autovector, const value_type>;
-  typedef std::reverse_iterator<iterator> reverse_iterator;
+  using reverse_iterator = std::reverse_iterator<iterator>;
-  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
   autovector() : values_(reinterpret_cast<pointer>(buf_)) {}
 

util/autovector_test.cc

@@ -64,7 +64,7 @@ TEST_F(AutoVectorTest, PushBackAndPopBack) {
 }
 
 TEST_F(AutoVectorTest, EmplaceBack) {
-  typedef std::pair<size_t, std::string> ValType;
+  using ValType = std::pair<size_t, std::string>;
   autovector<ValType, kSize> vec;
 
   for (size_t i = 0; i < 1000 * kSize; ++i) {

util/crc32c.cc

@@ -459,7 +459,7 @@ static bool isPCLMULQDQ() {
 #endif  // HAVE_POWER8
 #endif  // HAVE_ARM64_CRC
 
-typedef uint32_t (*Function)(uint32_t, const char*, size_t);
+using Function = uint32_t (*)(uint32_t, const char*, size_t);
 
 #if defined(HAVE_POWER8) && defined(HAS_ALTIVEC)
 uint32_t ExtendPPCImpl(uint32_t crc, const char *buf, size_t size) {
@@ -1320,7 +1320,7 @@ struct gf_powers_memo<0, m> {
 
 template <typename T, T... Ints>
 struct integer_sequence {
-  typedef T value_type;
+  using value_type = T;
   static constexpr size_t size() { return sizeof...(Ints); }
 };
 

util/kv_map.h

@@ -28,6 +28,6 @@ struct LessOfComparator {
   const Comparator* cmp;
 };
 
-typedef std::map<std::string, std::string, LessOfComparator> KVMap;
+using KVMap = std::map<std::string, std::string, LessOfComparator>;
 }
 }  // namespace ROCKSDB_NAMESPACE

util/murmurhash.h

@@ -17,19 +17,19 @@
 #define MURMUR_HASH MurmurHash64A
 uint64_t MurmurHash64A ( const void * key, int len, unsigned int seed );
 #define MurmurHash MurmurHash64A
-typedef uint64_t murmur_t;
+using murmur_t = uint64_t;
 
 #elif defined(__i386__)
 #define MURMUR_HASH MurmurHash2
 unsigned int MurmurHash2 ( const void * key, int len, unsigned int seed );
 #define MurmurHash MurmurHash2
-typedef unsigned int murmur_t;
+using murmur_t = unsigned int;
 
 #else
 #define MURMUR_HASH MurmurHashNeutral2
 unsigned int MurmurHashNeutral2 ( const void * key, int len, unsigned int seed );
 #define MurmurHash MurmurHashNeutral2
-typedef unsigned int murmur_t;
+using murmur_t = unsigned int;
 #endif
 
 // Allow slice to be hashable by murmur hash.

util/thread_local.h

@@ -31,7 +31,7 @@ namespace ROCKSDB_NAMESPACE {
 // is needed to avoid deadlocks. In particular, the handler shouldn't lock any
 // mutexes and shouldn't call any methods of any ThreadLocalPtr instances,
 // unless you know what you're doing.
-typedef void (*UnrefHandler)(void* ptr);
+using UnrefHandler = void (*)(void* ptr);
 
 // ThreadLocalPtr stores only values of pointer type.  Different from
 // the usual thread-local-storage, ThreadLocalPtr has the ability to
@@ -69,7 +69,7 @@ class ThreadLocalPtr {
   // data for all existing threads
   void Scrape(autovector<void*>* ptrs, void* const replacement);
 
-  typedef std::function<void(void*, void*)> FoldFunc;
+  using FoldFunc = std::function<void(void*, void*)>;
   // Update res by applying func on each thread-local value. Holds a lock that
   // prevents unref handler from running during this call, but clients must
   // still provide external synchronization since the owning thread can

utilities/cassandra/format.h

@@ -142,7 +142,7 @@ private:
   std::chrono::seconds Ttl() const;
 };
 
-typedef std::vector<std::shared_ptr<ColumnBase>> Columns;
+using Columns = std::vector<std::shared_ptr<ColumnBase>>;
 
 class RowValue {
 public:

utilities/env_librados_test.cc

@@ -20,9 +20,10 @@
 #include "rocksdb/utilities/transaction_db.h"
 
 class Timer {
-  typedef std::chrono::high_resolution_clock high_resolution_clock;
+  using high_resolution_clock = std::chrono::high_resolution_clock;
-  typedef std::chrono::milliseconds milliseconds;
+  using milliseconds = std::chrono::milliseconds;
-public:
+
+ public:
   explicit Timer(bool run = false)
   {
     if (run)

utilities/merge_operators/string_append/stringappend_test.cc

@@ -149,7 +149,7 @@ class StringAppendOperatorTest : public testing::Test,
     StringAppendOperatorTest::SetOpenDbFunction(&OpenNormalDb);
   }
 
-  typedef std::shared_ptr<DB> (*OpenFuncPtr)(const std::string&);
+  using OpenFuncPtr = std::shared_ptr<DB> (*)(const std::string&);
 
   // Allows user to open databases with different configurations.
   // e.g.: Can open a DB or a TtlDB, etc.

utilities/persistent_cache/block_cache_tier_file.h

@@ -65,7 +65,7 @@ struct LogicalBlockAddress {
   uint32_t size_ = 0;
 };
 
-typedef LogicalBlockAddress LBA;
+using LBA = LogicalBlockAddress;
 
 // class Writer
 //

utilities/persistent_cache/block_cache_tier_metadata.h

@@ -95,9 +95,9 @@ class BlockCacheTierMetadata {
     }
   };
 
-  typedef EvictableHashTable<BlockCacheFile, BlockCacheFileHash,
+  using CacheFileIndexType =
-                             BlockCacheFileEqual>
+      EvictableHashTable<BlockCacheFile, BlockCacheFileHash,
-      CacheFileIndexType;
+                         BlockCacheFileEqual>;
 
   // Block Lookup Index
   //
@@ -114,7 +114,7 @@ class BlockCacheTierMetadata {
     }
   };
 
-  typedef HashTable<BlockInfo*, Hash, Equal> BlockIndexType;
+  using BlockIndexType = HashTable<BlockInfo*, Hash, Equal>;
 
   CacheFileIndexType cache_file_index_;
   BlockIndexType block_index_;

utilities/persistent_cache/hash_table_evictable.h

@@ -24,7 +24,7 @@ namespace ROCKSDB_NAMESPACE {
 template <class T, class Hash, class Equal>
 class EvictableHashTable : private HashTable<T*, Hash, Equal> {
  public:
-  typedef HashTable<T*, Hash, Equal> hash_table;
+  using hash_table = HashTable<T*, Hash, Equal>;
 
   explicit EvictableHashTable(const size_t capacity = 1024 * 1024,
                               const float load_factor = 2.0,
@@ -141,7 +141,7 @@ class EvictableHashTable : private HashTable<T*, Hash, Equal> {
   port::RWMutex* GetMutex(T* t) { return hash_table::GetMutex(t); }
 
  private:
-  typedef LRUList<T> LRUListType;
+  using LRUListType = LRUList<T>;
 
   typename hash_table::Bucket& GetBucket(const uint64_t h) {
     const uint32_t bucket_idx = h % hash_table::nbuckets_;

utilities/persistent_cache/persistent_cache_tier.h

@@ -235,7 +235,7 @@ struct PersistentCacheConfig {
 // to enable management and stacking of tiers.
 class PersistentCacheTier : public PersistentCache {
  public:
-  typedef std::shared_ptr<PersistentCacheTier> Tier;
+  using Tier = std::shared_ptr<PersistentCacheTier>;
 
   virtual ~PersistentCacheTier() {}
 

utilities/persistent_cache/volatile_tier_impl.h

@@ -124,8 +124,8 @@ class VolatileCacheTier : public PersistentCacheTier {
     }
   };
 
-  typedef EvictableHashTable<CacheData, CacheDataHash, CacheDataEqual>
+  using IndexType =
-      IndexType;
+      EvictableHashTable<CacheData, CacheDataHash, CacheDataEqual>;
 
   // Evict LRU tail
   bool Evict();

utilities/transactions/lock/point/point_lock_manager.h

@@ -98,7 +98,7 @@ class DeadlockInfoBufferTempl {
   }
 };
 
-typedef DeadlockInfoBufferTempl<DeadlockPath> DeadlockInfoBuffer;
+using DeadlockInfoBuffer = DeadlockInfoBufferTempl<DeadlockPath>;
 
 struct TrackedTrxInfo {
   autovector<TransactionID> m_neighbors;

utilities/transactions/lock/point/point_lock_manager_test.h

@@ -78,7 +78,7 @@ class PointLockManagerTest : public testing::Test {
   TransactionDB* db_;
 };
 
-typedef void (*init_func_t)(PointLockManagerTest*);
+using init_func_t = void (*)(PointLockManagerTest*);
 
 class AnyLockManagerTest : public PointLockManagerTest,
                            public testing::WithParamInterface<init_func_t> {

utilities/ttl/ttl_test.cc

@@ -25,7 +25,7 @@ namespace ROCKSDB_NAMESPACE {
 
 namespace {
 
-typedef std::map<std::string, std::string> KVMap;
+using KVMap = std::map<std::string, std::string>;
 
 enum BatchOperation { OP_PUT = 0, OP_DELETE = 1 };
 }

utilities/write_batch_with_index/write_batch_with_index_internal.h

@@ -174,8 +174,8 @@ class WriteBatchEntryComparator {
   const ReadableWriteBatch* write_batch_;
 };
 
-typedef SkipList<WriteBatchIndexEntry*, const WriteBatchEntryComparator&>
+using WriteBatchEntrySkipList =
-    WriteBatchEntrySkipList;
+    SkipList<WriteBatchIndexEntry*, const WriteBatchEntryComparator&>;
 
 class WBWIIteratorImpl : public WBWIIterator {
  public: