Style Change: NULL->nullptr

src/core/SkTDynamicHash.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkTDynamicHash_DEFINED
 #define SkTDynamicHash_DEFINED
 
 #include "SkMath.h"
 #include "SkTemplates.h"
 #include "SkTypes.h"
 
 // Traits requires:
 //   static const Key& GetKey(const T&) { ... }
 //   static uint32_t Hash(const Key&) { ... }
 // We'll look on T for these by default, or you can pass a custom Traits type.
 template <typename T,
           typename Key,
           typename Traits = T,
           int kGrowPercent = 75>  // Larger -> more memory efficient, but slower.
 class SkTDynamicHash {
 public:
-    SkTDynamicHash() : fCount(0), fDeleted(0), fCapacity(0), fArray(NULL) {
+    SkTDynamicHash() : fCount(0), fDeleted(0), fCapacity(0), fArray(nullptr) {
         SkASSERT(this->validate());
     }
 
     ~SkTDynamicHash() {
         sk_free(fArray);
     }
 
     class Iter {
     public:
         explicit Iter(SkTDynamicHash* hash) : fHash(hash), fCurrentIndex(-1) {
@@ skipping 43 matching lines @@
 
     private:
         const T* current() const { return fHash->fArray[fCurrentIndex]; }
 
         const SkTDynamicHash* fHash;
         int fCurrentIndex;
     };
 
     int count() const { return fCount; }
 
-    // Return the entry with this key if we have it, otherwise NULL.
+    // Return the entry with this key if we have it, otherwise nullptr.
     T* find(const Key& key) const {
         int index = this->firstIndex(key);
         for (int round = 0; round < fCapacity; round++) {
             SkASSERT(index >= 0 && index < fCapacity);
             T* candidate = fArray[index];
             if (Empty() == candidate) {
-                return NULL;
+                return nullptr;
             }
             if (Deleted() != candidate && GetKey(*candidate) == key) {
                 return candidate;
             }
             index = this->nextIndex(index, round);
         }
         SkASSERT(fCapacity == 0);
-        return NULL;
+        return nullptr;
     }
 
     // Add an entry with this key.  We require that no entry with newEntry's key is already present.
     void add(T* newEntry) {
-        SkASSERT(NULL == this->find(GetKey(*newEntry)));
+        SkASSERT(nullptr == this->find(GetKey(*newEntry)));
         this->maybeGrow();
         this->innerAdd(newEntry);
         SkASSERT(this->validate());
     }
 
     // Remove the entry with this key.  We require that an entry with this key is present.
     void remove(const Key& key) {
         SkASSERT(this->find(key));
         this->innerRemove(key);
         SkASSERT(this->validate());
     }
 
     void rewind() {
         if (fArray) {
             sk_bzero(fArray, sizeof(T*)* fCapacity);
         }
         fCount = 0;
         fDeleted = 0;
     }
 
     void reset() { 
         fCount = 0; 
         fDeleted = 0; 
         fCapacity = 0; 
         sk_free(fArray); 
-        fArray = NULL; 
+        fArray = nullptr; 
     }
 
 protected:
     // These methods are used by tests only.
 
     int capacity() const { return fCapacity; }
 
     // How many collisions do we go through before finding where this entry should be inserted?
     int countCollisions(const Key& key) const {
         int index = this->firstIndex(key);
         for (int round = 0; round < fCapacity; round++) {
             SkASSERT(index >= 0 && index < fCapacity);
             const T* candidate = fArray[index];
             if (Empty() == candidate || Deleted() == candidate || GetKey(*candidate) == key) {
                 return round;
             }
             index = this->nextIndex(index, round);
         }
         SkASSERT(fCapacity == 0);
         return 0;
     }
 
 private:
     // We have two special values to indicate an empty or deleted entry.
-    static T* Empty()   { return reinterpret_cast<T*>(0); }  // i.e. NULL
+    static T* Empty()   { return reinterpret_cast<T*>(0); }  // i.e. nullptr
     static T* Deleted() { return reinterpret_cast<T*>(1); }  // Also an invalid pointer.
 
     bool validate() const {
         #define SKTDYNAMICHASH_CHECK(x) SkASSERT(x); if (!(x)) return false
         static const int kLarge = 50;  // Arbitrary, tweak to suit your patience.
 
         // O(1) checks, always done.
         // Is capacity sane?
         SKTDYNAMICHASH_CHECK(SkIsPow2(fCapacity));
 
@@ skipping 109 matching lines @@
     static const Key& GetKey(const T& t) { return Traits::GetKey(t); }
     static uint32_t Hash(const Key& key) { return Traits::Hash(key); }
 
     int fCount;     // Number of non Empty(), non Deleted() entries in fArray.
     int fDeleted;   // Number of Deleted() entries in fArray.
     int fCapacity;  // Number of entries in fArray.  Always a power of 2.
     T** fArray;
 };
 
 #endif