Style Change: NULL->nullptr

src/core/SkMetaData.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkMetaData.h"
 #include "SkRefCnt.h"
 
 struct PtrPair {
     void*               fPtr;
     SkMetaData::PtrProc fProc;
 };
 
 void* SkMetaData::RefCntProc(void* ptr, bool doRef) {
     SkASSERT(ptr);
     SkRefCnt* refcnt = reinterpret_cast<SkRefCnt*>(ptr);
 
     if (doRef) {
         refcnt->ref();
     } else {
         refcnt->unref();
     }
     return ptr;
 }
 
-SkMetaData::SkMetaData() : fRec(NULL)
+SkMetaData::SkMetaData() : fRec(nullptr)
 {
 }
 
-SkMetaData::SkMetaData(const SkMetaData& src) : fRec(NULL)
+SkMetaData::SkMetaData(const SkMetaData& src) : fRec(nullptr)
 {
     *this = src;
 }
 
 SkMetaData::~SkMetaData()
 {
     this->reset();
 }
 
 void SkMetaData::reset()
 {
     Rec* rec = fRec;
     while (rec) {
         if (kPtr_Type == rec->fType) {
             PtrPair* pair = (PtrPair*)rec->data();
             if (pair->fProc && pair->fPtr) {
                 pair->fPtr = pair->fProc(pair->fPtr, false);
             }
         }
         Rec* next = rec->fNext;
         Rec::Free(rec);
         rec = next;
     }
-    fRec = NULL;
+    fRec = nullptr;
 }
 
 SkMetaData& SkMetaData::operator=(const SkMetaData& src)
 {
     this->reset();
 
     const Rec* rec = src.fRec;
     while (rec)
     {
         this->set(rec->name(), rec->data(), rec->fDataLen, (Type)rec->fType, rec->fDataCount);
@@ skipping 10 matching lines @@
 void SkMetaData::setScalar(const char name[], SkScalar value)
 {
     (void)this->set(name, &value, sizeof(SkScalar), kScalar_Type, 1);
 }
 
 SkScalar* SkMetaData::setScalars(const char name[], int count, const SkScalar values[])
 {
     SkASSERT(count > 0);
     if (count > 0)
         return (SkScalar*)this->set(name, values, sizeof(SkScalar), kScalar_Type, count);
-    return NULL;
+    return nullptr;
 }
 
 void SkMetaData::setString(const char name[], const char value[])
 {
     (void)this->set(name, value, sizeof(char), kString_Type, SkToInt(strlen(value) + 1));
 }
 
 void SkMetaData::setPtr(const char name[], void* ptr, PtrProc proc) {
     PtrPair pair = { ptr, proc };
     (void)this->set(name, &pair, sizeof(PtrPair), kPtr_Type, 1);
@@ skipping 72 matching lines @@
 {
     const Rec* rec = this->find(name, kScalar_Type);
     if (rec)
     {
         if (count)
             *count = rec->fDataCount;
         if (values)
             memcpy(values, rec->data(), rec->fDataCount * rec->fDataLen);
         return (const SkScalar*)rec->data();
     }
-    return NULL;
+    return nullptr;
 }
 
 bool SkMetaData::findPtr(const char name[], void** ptr, PtrProc* proc) const {
     const Rec* rec = this->find(name, kPtr_Type);
     if (rec) {
         SkASSERT(rec->fDataCount == 1);
         const PtrPair* pair = (const PtrPair*)rec->data();
         if (ptr) {
             *ptr = pair->fPtr;
         }
         if (proc) {
             *proc = pair->fProc;
         }
         return true;
     }
     return false;
 }
 
 const char* SkMetaData::findString(const char name[]) const
 {
     const Rec* rec = this->find(name, kString_Type);
-    SkASSERT(rec == NULL || rec->fDataLen == sizeof(char));
-    return rec ? (const char*)rec->data() : NULL;
+    SkASSERT(rec == nullptr || rec->fDataLen == sizeof(char));
+    return rec ? (const char*)rec->data() : nullptr;
 }
 
 bool SkMetaData::findBool(const char name[], bool* value) const
 {
     const Rec* rec = this->find(name, kBool_Type);
     if (rec)
     {
         SkASSERT(rec->fDataCount == 1);
         if (value)
             *value = *(const bool*)rec->data();
         return true;
     }
     return false;
 }
 
 const void* SkMetaData::findData(const char name[], size_t* length) const {
     const Rec* rec = this->find(name, kData_Type);
     if (rec) {
         SkASSERT(rec->fDataLen == sizeof(char));
         if (length) {
             *length = rec->fDataCount;
         }
         return rec->data();
     }
-    return NULL;
+    return nullptr;
 }
 
 const SkMetaData::Rec* SkMetaData::find(const char name[], Type type) const
 {
     const Rec* rec = fRec;
     while (rec)
     {
         if (rec->fType == type && !strcmp(rec->name(), name))
             return rec;
         rec = rec->fNext;
     }
-    return NULL;
+    return nullptr;
 }
 
 bool SkMetaData::remove(const char name[], Type type) {
     Rec* rec = fRec;
-    Rec* prev = NULL;
+    Rec* prev = nullptr;
     while (rec) {
         Rec* next = rec->fNext;
         if (rec->fType == type && !strcmp(rec->name(), name)) {
             if (prev) {
                 prev->fNext = next;
             } else {
                 fRec = next;
             }
 
             if (kPtr_Type == type) {
@@ skipping 44 matching lines @@
 
 SkMetaData::Iter::Iter(const SkMetaData& metadata) {
     fRec = metadata.fRec;
 }
 
 void SkMetaData::Iter::reset(const SkMetaData& metadata) {
     fRec = metadata.fRec;
 }
 
 const char* SkMetaData::Iter::next(SkMetaData::Type* t, int* count) {
-    const char* name = NULL;
+    const char* name = nullptr;
 
     if (fRec) {
         if (t) {
             *t = (SkMetaData::Type)fRec->fType;
         }
         if (count) {
             *count = fRec->fDataCount;
         }
         name = fRec->name();
 
         fRec = fRec->fNext;
     }
     return name;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkMetaData::Rec* SkMetaData::Rec::Alloc(size_t size) {
     return (Rec*)sk_malloc_throw(size);
 }
 
 void SkMetaData::Rec::Free(Rec* rec) {
     sk_free(rec);
 }