Changeset 10768 for code/branches/cpp11_v2/src/libraries/util

Timestamp:

Nov 6, 2015, 10:54:34 PM (9 years ago)

Author:

landauf

Message:

replace '0' by 'nullptr'

Location:

code/branches/cpp11_v2/src/libraries/util

Files:

• Math.h (modified) (1 diff)
• MultiType.h (modified) (4 diffs)
• MultiTypeValue.h (modified) (1 diff)
• SharedPtr.h (modified) (4 diffs)
• SignalHandler.cc (modified) (2 diffs)
• SmallObjectAllocator.cc (modified) (2 diffs)
• output/OutputManager.cc (modified) (1 diff)

code/branches/cpp11_v2/src/libraries/util/Math.h

@@ -200 +200 @@
     template <> inline long double          zeroise<long double>()          { return 0; }
     template <> inline bool                 zeroise<bool>()                 { return 0; }
-    template <> inline void*                zeroise<void*>()                { return 0; }
+    template <> inline void*                zeroise<void*>()                { return nullptr; }
     template <> inline std::string          zeroise<std::string>()          { return std::string(); }
     template <> inline orxonox::Radian      zeroise<orxonox::Radian>()      { return orxonox::Radian(0.0f); }

code/branches/cpp11_v2/src/libraries/util/MultiType.h

@@ -266 +266 @@
 
             /// Default constructor: Assigns no value and no type. The type will be determined by the first assignment of a value.
-            inline MultiType()                       : value_(0) { }
+            inline MultiType()                       : value_(nullptr) { }
             /// Constructor: Assigns the given value and sets the type.
             template <typename V>
-            inline MultiType(const V& value)         : value_(0) { this->set(value); }
+            inline MultiType(const V& value)         : value_(nullptr) { this->set(value); }
             /// Copyconstructor: Assigns value and type of the other MultiType.
-            inline MultiType(const MultiType& other) : value_(0) { this->set(other); }
+            inline MultiType(const MultiType& other) : value_(nullptr) { this->set(other); }
 
             /// Destructor: Deletes the MT_Value.
@@ -325 +325 @@
                 if (this->value_)
                     delete this->value_;
-                this->value_ = (other.value_) ? other.value_->clone() : 0;
+                this->value_ = (other.value_) ? other.value_->clone() : nullptr;
             }
 
@@ -332 +332 @@
 
             /// Resets value and type. Type will be void afterwards and null() returns true.
-            inline void reset() { if (this->value_) delete this->value_; this->value_ = 0; }
+            inline void reset() { if (this->value_) delete this->value_; this->value_ = nullptr; }
             /// Resets the value and changes the internal type to T.
             template <typename T> inline void reset() { this->assignValue(typename Loki::TypeTraits<T>::UnqualifiedReferredType()); }
@@ -486 +486 @@
     template <> inline long double          MultiType::get() const { return (this->value_ ? this->value_->get<long double>()          : 0); }
     template <> inline bool                 MultiType::get() const { return (this->value_ ? this->value_->get<bool>()                 : 0); }
-    template <> inline void*                MultiType::get() const { return (this->value_ ? this->value_->get<void*>()                : 0); }
+    template <> inline void*                MultiType::get() const { return (this->value_ ? this->value_->get<void*>()                : nullptr); }
     template <> inline std::string          MultiType::get() const { return (this->value_ ? this->value_->get<std::string>()          : NilValue<std::string>()); }
     template <> inline orxonox::Vector2     MultiType::get() const { return (this->value_ ? this->value_->get<orxonox::Vector2>()     : NilValue<orxonox::Vector2>()); }

code/branches/cpp11_v2/src/libraries/util/MultiTypeValue.h

@@ -77 +77 @@
         inline bool getValue(long double*          value) const { return convertValue<T, long double         >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
         inline bool getValue(bool*                 value) const { return convertValue<T, bool                >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(void**                value) const { return convertValue<T, void*               >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(void**                value) const { return convertValue<T, void*               >(value, value_, nullptr); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
         inline bool getValue(std::string*          value) const { return convertValue<T, std::string         >(value, value_, NilValue<std::string>         ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
         inline bool getValue(orxonox::Vector2*     value) const { return convertValue<T, orxonox::Vector2    >(value, value_, NilValue<orxonox::Vector2>    ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.

code/branches/cpp11_v2/src/libraries/util/SharedPtr.h

@@ -216 +216 @@
         public:
             /// Default constructor, the pointer is set to nullptr.
-            inline SharedPtr() : pointer_(0), counter_(0)
+            inline SharedPtr() : pointer_(nullptr), counter_(nullptr)
             {
             }
 
             /// Constructor, creates a SharedPtr that points to @a pointer, increments the counter.
-            inline SharedPtr(T* pointer) : pointer_(pointer), counter_(0)
+            inline SharedPtr(T* pointer) : pointer_(pointer), counter_(nullptr)
             {
                 if (this->pointer_)
@@ -293 +293 @@
             inline T* operator->() const
             {
-                assert(this->pointer_ != 0);
+                assert(this->pointer_ != nullptr);
                 return this->pointer_;
             }
@@ -300 +300 @@
             inline T& operator*() const
             {
-                assert(this->pointer_ != 0);
+                assert(this->pointer_ != nullptr);
                 return *this->pointer_;
             }
@@ -313 +313 @@
             inline operator bool() const
             {
-                return (this->pointer_ != 0);
+                return (this->pointer_ != nullptr);
             }
 

code/branches/cpp11_v2/src/libraries/util/SignalHandler.cc

@@ -127 +127 @@
       }
       // if the signalhandler has already been destroyed then don't do anything
-      if( SignalHandler::singletonPtr_s == 0 )
+      if( SignalHandler::singletonPtr_s == nullptr )
       {
         orxout(user_error) << "Received signal " << sigName.c_str() << endl << "Can't write backtrace because SignalHandler is already destroyed" << endl;
@@ -430 +430 @@
 
             // if the signalhandler has already been destroyed then don't do anything
-            if (SignalHandler::singletonPtr_s == 0)
+            if (SignalHandler::singletonPtr_s == nullptr)
             {
                 orxout(user_error) << "Caught an unhandled exception" << endl << "Can't write backtrace because SignalHandler is already destroyed" << endl;

code/branches/cpp11_v2/src/libraries/util/SmallObjectAllocator.cc

@@ -45 +45 @@
         this->chunkSize_ = std::max(objectSize, sizeof(Chunk)); // the chunk's size will be the maximum of the object's size and the size of a Chunk object itself
         this->numChunksPerBlock_ = numObjects;
-        this->first_ = 0;
+        this->first_ = nullptr;
     }
 
@@ -98 +98 @@
 
             // the next_ pointer of the last chunk must point to nullptr
-            setNext(block + (this->numChunksPerBlock_ - 1) * this->chunkSize_, 0);
+            setNext(block + (this->numChunksPerBlock_ - 1) * this->chunkSize_, nullptr);
 
             // The second chunk in the block is assigned to the first_ pointer

code/branches/cpp11_v2/src/libraries/util/output/OutputManager.cc

@@ -57 +57 @@
 
         this->isInitialized_ = false;
-        this->memoryWriterInstance_ = 0;
-        this->consoleWriterInstance_ = 0;
-        this->logWriterInstance_ = 0;
+        this->memoryWriterInstance_ = nullptr;
+        this->consoleWriterInstance_ = nullptr;
+        this->logWriterInstance_ = nullptr;
 
         // register 'undefined' context in order to give it always the first context-ID