using nullptr instead of NULL

petergjoel · May 14, 2019 · c670389 · c670389
1 parent f049f77
commit c670389
Show file tree

Hide file tree

Showing 5 changed files with 59 additions and 59 deletions.
diff --git a/src/binarywrapper.cpp b/src/binarywrapper.cpp
@@ -84,7 +84,7 @@ namespace ptrie
         if(size == 0 || offset >= encodingsize)
         {
             _nbytes = 0;
-            _blob = NULL;            
+            _blob = nullptr;            
             return;
         }
 
@@ -96,7 +96,7 @@ namespace ptrie
             _nbytes -= offset;
         else {
             _nbytes = 0;
-            _blob = NULL;
+            _blob = nullptr;
             return;
         }
 

diff --git a/src/binarywrapper.h b/src/binarywrapper.h
@@ -53,7 +53,7 @@ namespace ptrie
          * Empty constructor, no data is allocated
          */
 
-        binarywrapper_t() : _blob(NULL), _nbytes(0)
+        binarywrapper_t() : _blob(nullptr), _nbytes(0)
         {            
         }
 
@@ -229,7 +229,7 @@ namespace ptrie
 
         inline void zero() const
         {
-            if(_nbytes > 0 && _blob != NULL)
+            if(_nbytes > 0 && _blob != nullptr)
             {
                 memset(const_raw(), 0x0, _nbytes); 
             }
@@ -243,7 +243,7 @@ namespace ptrie
         {
             if(_nbytes > __BW_BSIZE__)
                 dealloc(_blob);
-            _blob = NULL;
+            _blob = nullptr;
             _nbytes = 0;
         }
 

diff --git a/src/linked_bucket.h b/src/linked_bucket.h
@@ -55,16 +55,16 @@ class linked_bucket_t {
     linked_bucket_t(size_t threads)
     : _tnext(threads) {
         for (size_t i = 0; i < threads; ++i) {
-            _tnext[i] = NULL;
+            _tnext[i] = nullptr;
         }
         _begin = new bucket_t;
         _begin->_count = 0;
         _begin->_offset = 0;
-        _begin->_nbucket = NULL;
+        _begin->_nbucket = nullptr;
         _tnext[0] = _begin;
 
         _index = new index_t;
-        _index->_next = NULL;
+        _index->_next = nullptr;
 
         memset(&_begin->_data, 0, sizeof(T)*C);        
         memset(&_index->_index, 0, sizeof(bucket_t*)*C);
@@ -78,19 +78,19 @@ class linked_bucket_t {
             delete _begin;
             _begin = n;
 
-        } while (_begin != NULL);
+        } while (_begin != nullptr);
 
         do {
             index_t* n = _index->_next.load();
             delete _index;
             _index = n;
 
-        } while (_index != NULL);
+        } while (_index != nullptr);
     }
 
     inline T& operator[](size_t i) {
         bucket_t* n = indexToBucket(i);
-        if(n != NULL)
+        if(n != nullptr)
         {
             return n->_data[i % C];
         }
@@ -100,8 +100,8 @@ class linked_bucket_t {
         while (b <= i) {
             b += C;
             n = n->_nbucket.load();
-            if(n == NULL) std::cerr << "FAILED FETCHING ID: " << i << std::endl;
-            assert(n != NULL);
+            if(n == nullptr) std::cerr << "FAILED FETCHING ID: " << i << std::endl;
+            assert(n != nullptr);
         }
 
         return n->_data[i % C];
@@ -110,7 +110,7 @@ class linked_bucket_t {
     inline const T& operator[](size_t i) const {
 
         bucket_t* n = indexToBucket(i);
-        if(n != NULL)
+        if(n != nullptr)
         {
             return n->_data[i % C];
         }
@@ -121,7 +121,7 @@ class linked_bucket_t {
         while (b <= i) {
             b += C;
             n = n->_nbucket.load();
-            assert(n != NULL);
+            assert(n != nullptr);
         }
 
         return n->_data[i % C];
@@ -130,33 +130,33 @@ class linked_bucket_t {
     size_t size() {
         bucket_t* n = _begin;
         size_t cnt = 0;
-        while (n != NULL) {
+        while (n != nullptr) {
             cnt += n->_count;
             n = n->_nbucket.load();
         }
         return cnt;
     }
 
     inline size_t next(size_t thread) {
-        if (_tnext[thread] == NULL || _tnext[thread]->_count == C) {
+        if (_tnext[thread] == nullptr || _tnext[thread]->_count == C) {
             bucket_t* next = new bucket_t;
             next->_count = 0;
-            next->_nbucket = NULL;
+            next->_nbucket = nullptr;
             next->_offset = 0;
             memset(&next->_data, 0, sizeof(T)*C);
 
             bucket_t* n = _tnext[thread];
-            if (n == NULL) {
+            if (n == nullptr) {
                 n = _begin;
             }
 
             next->_offset = n->_offset.load() + C; // beginning of next
 
-            bucket_t* tmp = NULL;
+            bucket_t* tmp = nullptr;
 
             while (!n->_nbucket.compare_exchange_weak(tmp, next)) {
-                if (tmp != NULL) {
-                    assert(tmp != NULL);
+                if (tmp != nullptr) {
+                    assert(tmp != nullptr);
                     n = tmp;
                     next->_offset += C;
                 }
@@ -174,7 +174,7 @@ class linked_bucket_t {
 
     inline void pop_back(size_t thread)
     {
-        assert(_tnext[thread] != NULL && _tnext[thread]->_count > 0);
+        assert(_tnext[thread] != nullptr && _tnext[thread]->_count > 0);
         --_tnext[thread]->_count;
     }
 
@@ -187,7 +187,7 @@ class linked_bucket_t {
             {
                 index_t* old = tmp;
                 tmp = old->_next;
-                if(tmp == NULL)
+                if(tmp == nullptr)
                 {
                     // extend index if needed
                     index_t* nindex = new index_t;
@@ -215,7 +215,7 @@ class linked_bucket_t {
             while(id >= C*C)
             {
                 tmp = tmp->_next;
-                if(tmp == NULL) return NULL;
+                if(tmp == nullptr) return nullptr;
                 id -= C*C;
             }
             return tmp->_index[id/C];