Convert NULL to nullptr

client/simple_string_dictionary.h

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 60 matching lines @@
 
   //! \brief An iterator to traverse all of the active entries in a
   //!     TSimpleStringDictionary.
   class Iterator {
    public:
     explicit Iterator(const TSimpleStringDictionary& map)
         : map_(map),
           current_(0) {
     }
 
-    //! \brief Returns the next entry in the map, or `NULL` if at the end of the
-    //!     collection.
+    //! \brief Returns the next entry in the map, or `nullptr` if at the end of
+    //!     the collection.
     const Entry* Next() {
       while (current_ < map_.num_entries) {
         const Entry* entry = &map_.entries_[current_++];
         if (entry->is_active()) {
           return entry;
         }
       }
-      return NULL;
+      return nullptr;
     }
 
    private:
     const TSimpleStringDictionary& map_;
     size_t current_;
 
     DISALLOW_COPY_AND_ASSIGN(Iterator);
   };
 
   TSimpleStringDictionary()
@@ skipping 26 matching lines @@
     for (size_t i = 0; i < num_entries; ++i) {
       if (entries_[i].is_active()) {
         ++count;
       }
     }
     return count;
   }
 
   //! \brief Given \a key, returns its corresponding value.
   //!
-  //! \param[in] key The key to look up. This must not be `NULL`.
+  //! \param[in] key The key to look up. This must not be `nullptr`.
   //!
   //! \return The corresponding value for \a key, or if \a key is not found,
-  //!     `NULL`.
+  //!     `nullptr`.
   const char* GetValueForKey(const char* key) const {
     DCHECK(key);
     if (!key) {
-      return NULL;
+      return nullptr;
     }
 
     const Entry* entry = GetConstEntryForKey(key);
     if (!entry) {
-      return NULL;
+      return nullptr;
     }
 
     return entry->value;
   }
 
   //! \brief Stores \a value into \a key, replacing the existing value if \a key
   //!     is already present.
   //!
-  //! If there \a key is not yet in the map and the map is already full
-  //! (containing \a NumEntries active entries), this operation silently fails.
+  //! If \a key is not yet in the map and the map is already full (containing
+  //! \a NumEntries active entries), this operation silently fails.
   //!
-  //! \param[in] key The key to store. This must not be `NULL`.
-  //! \param[in] value The value to store. If `NULL`, \a key is removed from the
-  //!     map.
+  //! \param[in] key The key to store. This must not be `nullptr`.
+  //! \param[in] value The value to store. If `nullptr`, \a key is removed from
+  //!     the map.
   void SetKeyValue(const char* key, const char* value) {
     if (!value) {
       RemoveKey(key);
       return;
     }
 
     DCHECK(key);
     if (!key) {
       return;
     }
@@ skipping 13 matching lines @@
           entry = &entries_[i];
 
           strncpy(entry->key, key, key_size);
           entry->key[key_size - 1] = '\0';
 
           break;
         }
       }
     }
 
-    // If the map is out of space, entry will be NULL.
+    // If the map is out of space, |entry| will be nullptr.
     if (!entry) {
       return;
     }
 
 #ifndef NDEBUG
     // Sanity check that the key only appears once.
     int count = 0;
     for (size_t i = 0; i < num_entries; ++i) {
       if (strncmp(entries_[i].key, key, key_size) == 0) {
         ++count;
       }
     }
     DCHECK_EQ(count, 1);
 #endif
 
     strncpy(entry->value, value, value_size);
     entry->value[value_size - 1] = '\0';
   }
 
   //! \brief Removes \a key from the map.
   //!
-  //! If the key is not found, this is a no-op.
+  //! If \a key is not found, this is a no-op.
   //!
-  //! \param[in] key The key of the entry to remove. This must not be `NULL`.
+  //! \param[in] key The key of the entry to remove. This must not be `nullptr`.
   void RemoveKey(const char* key) {
     DCHECK(key);
     if (!key) {
       return;
     }
 
     Entry* entry = GetEntryForKey(key);
     if (entry) {
       entry->key[0] = '\0';
       entry->value[0] = '\0';
     }
 
-    DCHECK_EQ(GetEntryForKey(key), static_cast<void*>(NULL));
+    DCHECK_EQ(GetEntryForKey(key), static_cast<Entry*>(nullptr));
   }
 
   //! \brief Returns a serialized form of the map.
   //!
   //! Places a serialized version of the map into \a map and returns the size in
   //! bytes. Both \a map and the size should be passed to the deserializing
   //! constructor. Note that the serialized \a map is scoped to the lifetime of
   //! the non-serialized instance of this class. The \a map data can be copied
   //! across IPC boundaries.
   size_t Serialize(const SerializedSimpleStringDictionary** map) const {
     *map = reinterpret_cast<const SerializedSimpleStringDictionary*>(entries_);
     return sizeof(entries_);
   }
 
  private:
   const Entry* GetConstEntryForKey(const char* key) const {
     for (size_t i = 0; i < num_entries; ++i) {
       if (strncmp(key, entries_[i].key, key_size) == 0) {
         return &entries_[i];
       }
     }
-    return NULL;
+    return nullptr;
   }
 
   Entry* GetEntryForKey(const char* key) {
     return const_cast<Entry*>(GetConstEntryForKey(key));
   }
 
   Entry entries_[NumEntries];
 };
 
 //! \brief A TSimpleStringDictionary with default template parameters.
 //!
 //! For historical reasons this specialized version is available with the same
 //! size factors as a previous implementation.
 typedef TSimpleStringDictionary<256, 256, 64> SimpleStringDictionary;
 
 }  // namespace crashpad
 
 #endif  // CRASHPAD_CLIENT_SIMPLE_STRING_DICTIONARY_H_