Changeset 11054 for code/branches/cpp11_v3/src/libraries/util

Timestamp:

Jan 10, 2016, 1:54:11 PM (10 years ago)

Author:

landauf

Message:

merged branch cpp11_v2 into cpp11_v3

Location:

code/branches/cpp11_v3

Files:

• . (modified) (1 prop)
• src/libraries/util/CMakeLists.txt (modified) (1 diff)
• src/libraries/util/Clipboard.cc (modified) (1 diff)
• src/libraries/util/Clock.h (modified) (1 diff)
• src/libraries/util/DestructionHelper.h (modified) (3 diffs)
• src/libraries/util/DisplayStringConversions.h (modified) (1 diff)
• src/libraries/util/ExprParser.cc (modified) (2 diffs)
• src/libraries/util/ExprParser.h (modified) (1 diff)
• src/libraries/util/ImplicitConversion.h (modified) (1 diff)
• src/libraries/util/Math.cc (modified) (1 diff)
• src/libraries/util/Math.h (modified) (12 diffs)
• src/libraries/util/MultiType.h (modified) (6 diffs)
• src/libraries/util/MultiTypeValue.h (modified) (3 diffs)
• src/libraries/util/Serialise.h (modified) (2 diffs)
• src/libraries/util/SharedPtr.cc (deleted)
• src/libraries/util/SharedPtr.h (deleted)
• src/libraries/util/SignalHandler.cc (modified) (17 diffs)
• src/libraries/util/SignalHandler.h (modified) (1 diff)
• src/libraries/util/Singleton.h (modified) (5 diffs)
• src/libraries/util/SmallObjectAllocator.cc (modified) (3 diffs)
• src/libraries/util/SmallObjectAllocator.h (modified) (1 diff)
• src/libraries/util/StringUtils.cc (modified) (7 diffs)
• src/libraries/util/SubString.cc (modified) (1 diff)
• src/libraries/util/UtilPrereqs.h (modified) (1 diff)
• src/libraries/util/output/BaseWriter.cc (modified) (2 diffs)
• src/libraries/util/output/BaseWriter.h (modified) (1 diff)
• src/libraries/util/output/ConsoleWriter.h (modified) (2 diffs)
• src/libraries/util/output/LogWriter.cc (modified) (3 diffs)
• src/libraries/util/output/LogWriter.h (modified) (2 diffs)
• src/libraries/util/output/MemoryWriter.cc (modified) (2 diffs)
• src/libraries/util/output/MemoryWriter.h (modified) (2 diffs)
• src/libraries/util/output/OutputDefinitions.h (modified) (1 diff)
• src/libraries/util/output/OutputListener.cc (modified) (3 diffs)
• src/libraries/util/output/OutputManager.cc (modified) (7 diffs)
• src/libraries/util/output/OutputManager.h (modified) (5 diffs)
• src/libraries/util/output/OutputStream.cc (modified) (1 diff)
• src/libraries/util/output/SubcontextOutputListener.cc (modified) (1 diff)
• src/libraries/util/output/SubcontextOutputListener.h (modified) (1 diff)

code/branches/cpp11_v3/src/libraries/util/CMakeLists.txt

@@ -26 +26 @@
   CRC32.cc
   ExprParser.cc
-  SharedPtr.cc
   Sleep.cc
   SmallObjectAllocator.cc

code/branches/cpp11_v3/src/libraries/util/Clipboard.cc

@@ -93 +93 @@
             {
                 HANDLE hData = GetClipboardData(CF_TEXT);
-                if (hData == NULL)
+                if (hData == nullptr)
                     return "";
                 std::string output(static_cast<char*>(GlobalLock(hData)));

code/branches/cpp11_v3/src/libraries/util/Clock.h

@@ -102 +102 @@
 
     private:
-        /// Undefined
-        Clock(const Clock& instance);
+        // non-copyable:
+        Clock(const Clock&) = delete;
+        Clock& operator=(const Clock&) = delete;
 
         Ogre::Timer*       timer_;       ///< Ogre timer object

code/branches/cpp11_v3/src/libraries/util/DestructionHelper.h

@@ -36 +36 @@
     /** Deletes an object and resets the pointer
     @param object
-        Pointer to an object. Handing over NULL is safe.
+        Pointer to an object. Handing over nullptr is safe.
     */
     template <class T>
@@ -42 +42 @@
     {
         delete *object;
-        *object = NULL;
+        *object = nullptr;
     }
 
@@ -87 +87 @@
 
     private:
-        DestructionHelper(const DestructionHelper&); //!< Don't use (undefined)
+        // non-copyable:
+        DestructionHelper(const DestructionHelper&) = delete;
+        DestructionHelper& operator=(const DestructionHelper&) = delete;
 
         T* object_;

code/branches/cpp11_v3/src/libraries/util/DisplayStringConversions.h

@@ -51 +51 @@
             {
                 Ogre::UTFString::code_point cp;
-                for (unsigned int i = 0; i < input.size(); ++i)
+                for (const char& character : input)
                 {
-                  cp = input[i];
+                  cp = character;
                   cp &= 0xFF;
                   output->append(1, cp);

code/branches/cpp11_v3/src/libraries/util/ExprParser.cc

@@ -391 +391 @@
     }
 
-    char* ExprParser::parse_word(char* str)
+    void ExprParser::parse_word(char* str)
     {
         char* word = str;
@@ -402 +402 @@
             {
                 this->failed_ = true;
-                return '\0';
+                return;
             }
         };
         *word = '\0';
-        return str;
     }
 

code/branches/cpp11_v3/src/libraries/util/ExprParser.h

@@ -139 +139 @@
         float parse_expr_7();
         float parse_expr_8();
-        char* parse_word(char* str);
+        void parse_word(char* str);
         binary_operator parse_binary_operator();
         unary_operator parse_unary_operator();

code/branches/cpp11_v3/src/libraries/util/ImplicitConversion.h

@@ -68 +68 @@
     {
     private:
-        ImplicitConversion(); ImplicitConversion(const ImplicitConversion&); ~ImplicitConversion();
+        // static class, no instances allowed:
+        ImplicitConversion() = delete;
+        ImplicitConversion(const ImplicitConversion&) = delete;
+        ImplicitConversion& operator=(const ImplicitConversion&) = delete;
+        ~ImplicitConversion() = delete;
+
         // Gets chosen only if there is an implicit conversion from FromType to ToType.
         static char test(ToType);

code/branches/cpp11_v3/src/libraries/util/Math.cc

@@ -371 +371 @@
     }
 
+
+    namespace detail
+    {
+        std::mt19937 rngen;
+    }
+
     /**
         @brief Returns a unique number. This function will never return the same value twice.

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

@@ -46 +46 @@
 #include <cmath>
 #include <cstdlib>
+#include <random>
 
 #include <OgreMath.h>
@@ -73 +74 @@
     namespace math
     {
-        const float twoPi   = 6.283185482025146484375f;     ///< PI * 2
-        const float pi      = 3.1415927410125732421875f;    ///< PI
-        const float pi_2    = 1.57079637050628662109375f;   ///< PI / 2
-        const float pi_4    = 0.785398185253143310546875f;  ///< PI / 4
-        const float e       = 2.718281269073486328125f;     ///< e
-        const float sqrt2   = 1.41421353816986083984375f;   ///< sqrt(2)
-        const float sqrt2_2 = 0.707106769084930419921875f;  ///< sqrt(2) / 2
+        constexpr float twoPi   = 6.283185482025146484375f;     ///< PI * 2
+        constexpr float pi      = 3.1415927410125732421875f;    ///< PI
+        constexpr float pi_2    = 1.57079637050628662109375f;   ///< PI / 2
+        constexpr float pi_4    = 0.785398185253143310546875f;  ///< PI / 4
+        constexpr float e       = 2.718281269073486328125f;     ///< e
+        constexpr float sqrt2   = 1.41421353816986083984375f;   ///< sqrt(2)
+        constexpr float sqrt2_2 = 0.707106769084930419921875f;  ///< sqrt(2) / 2
     }
 
@@ -104 +105 @@
     */
     template <typename T>
-    inline T sgn(T x)
+    constexpr inline T sgn(T x)
     {
         return (x >= 0) ? (T)1 : (T)-1;
@@ -116 +117 @@
     */
     template <typename T>
-    inline T clamp(T x, T min, T max)
-    {
-        if (x < min)
-            return min;
-
-        if (x > max)
-            return max;
-
-        return x;
+    constexpr inline T clamp(T x, T min, T max)
+    {
+        return x < min ? min : (x > max ? max : x);
     }
 
@@ -131 +126 @@
     */
     template <typename T>
-    inline T square(T x)
+    constexpr inline T square(T x)
     {
         return x*x;
@@ -140 +135 @@
     */
     template <typename T>
-    inline T cube(T x)
+    constexpr inline T cube(T x)
     {
         return x*x*x;
@@ -186 +181 @@
     inline T zeroise()
     {
-        // Default, raise a compiler error without including large boost header cascade.
-        T temp();
-        *********temp; // If you reach this code, you abused zeroise()!
-        return temp;
+        // If you reach this code, you abused zeroise()!
+        static_assert(sizeof(T) != sizeof(T), "No template specialization available for T");
     }
 
@@ -206 +199 @@
     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); }
@@ -258 +251 @@
     }
 
+    namespace detail
+    {
+        /**
+        Random number generator used for the functions below. Marked extern to only have one global instance.
+        */
+        _UtilExport extern std::mt19937 rngen;
+    }
+
+    /**
+    @brief Seeds the random number generator used for the functions below.
+    */
+    inline void rndseed(unsigned int seed)
+    {
+        detail::rngen.seed(seed);
+    }
+
+    /**
+    @brief Returns a random number between @a min and almost @a max: <tt>min <= rnd < max</tt>.
+    @param min The minimum
+    @param max The maximum
+    */
+    inline float rnd(float min, float max)
+    {
+        std::uniform_real_distribution<float> dist(min, max);
+        return dist(detail::rngen);
+    }
+
     /**
         @brief Returns a random number between 0 and almost 1: <tt>0 <= rnd < 1</tt>.
@@ -263 +283 @@
     inline float rnd()
     {
-        return rand() / (RAND_MAX + 1.0f);
+        return rnd(0, 1);
     }
 
@@ -272 +292 @@
     inline float rnd(float max)
     {
-        return rnd() * max;
-    }
-
-    /**
-        @brief Returns a random number between @a min and almost @a max: <tt>min <= rnd < max</tt>.
-        @param min The minimum
-        @param max The maximum
-    */
-    inline float rnd(float min, float max)
-    {
-        return rnd(max - min) + min;
+        return rnd(0, max);
     }
 
@@ -290 +300 @@
     inline float rndsgn()
     {
-        return static_cast<float>((rand() & 0x2) - 1); // rand() & 0x2 is either 2 or 0
+        std::uniform_int_distribution<> dist;
+        return static_cast<float>((dist(detail::rngen) & 0x2) - 1); // dist(...) & 0x2 is either 2 or 0
     }
 

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

@@ -175 +175 @@
         public:
             inline MT_ValueBase(void* data, Type::Enum type) : type_(type), bLastConversionSuccessful(true), data_(data) {}
-            inline virtual ~MT_ValueBase() {}
+            virtual inline ~MT_ValueBase() {}
 
             virtual MT_ValueBase* clone() const = 0;
@@ -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()); }
@@ -428 +428 @@
             }
             /// Creates a new value container (works only with specialized types).
-            template <typename T> inline void createNewValueContainer(const T& value) { /* STATIC ASSERT */ *****value; return false; }
+            template <typename T> inline void createNewValueContainer(const T& value)
+            { 
+                // If you reach this code, you used MultiType with an unsupported type T
+                static_assert(sizeof(T) != sizeof(T), "No template specialization available for T");
+            }
 
             MT_ValueBase* value_; //!< A pointer to the value container
@@ -486 +490 @@
     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_v3/src/libraries/util/MultiTypeValue.h

@@ -58 +58 @@
 
         /// Creates a copy of itself.
-        inline MT_ValueBase* clone() const { return new MT_Value<T>(this->value_, this->type_); }
+        virtual inline MT_ValueBase* clone() const override { return new MT_Value<T>(this->value_, this->type_); }
 
         /// Resets the current value to the default.
-        inline void reset() { this->value_ = zeroise<T>(); bLastConversionSuccessful = true; }
-
-        inline bool getValue(char*                 value) const { return convertValue<T, char                >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(unsigned char*        value) const { return convertValue<T, unsigned char       >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(short*                value) const { return convertValue<T, short               >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(unsigned short*       value) const { return convertValue<T, unsigned short      >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(int*                  value) const { return convertValue<T, int                 >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(unsigned int*         value) const { return convertValue<T, unsigned int        >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(long*                 value) const { return convertValue<T, long                >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(unsigned long*        value) const { return convertValue<T, unsigned long       >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(long long*            value) const { return convertValue<T, long long           >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(unsigned long long*   value) const { return convertValue<T, unsigned long long  >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(float*                value) const { return convertValue<T, float               >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(double*               value) const { return convertValue<T, double              >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        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(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.
-        inline bool getValue(orxonox::Vector3*     value) const { return convertValue<T, orxonox::Vector3    >(value, value_, NilValue<orxonox::Vector3>    ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(orxonox::Vector4*     value) const { return convertValue<T, orxonox::Vector4    >(value, value_, NilValue<orxonox::Vector4>    ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(orxonox::ColourValue* value) const { return convertValue<T, orxonox::ColourValue>(value, value_, NilValue<orxonox::ColourValue>()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(orxonox::Quaternion*  value) const { return convertValue<T, orxonox::Quaternion >(value, value_, NilValue<orxonox::Quaternion> ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(orxonox::Radian*      value) const { return convertValue<T, orxonox::Radian     >(value, value_, NilValue<orxonox::Radian>     ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(orxonox::Degree*      value) const { return convertValue<T, orxonox::Degree     >(value, value_, NilValue<orxonox::Degree>     ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline void reset() override { this->value_ = zeroise<T>(); bLastConversionSuccessful = true; }
+
+        virtual inline bool getValue(char*                 value) const override { return convertValue<T, char                >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(unsigned char*        value) const override { return convertValue<T, unsigned char       >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(short*                value) const override { return convertValue<T, short               >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(unsigned short*       value) const override { return convertValue<T, unsigned short      >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(int*                  value) const override { return convertValue<T, int                 >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(unsigned int*         value) const override { return convertValue<T, unsigned int        >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(long*                 value) const override { return convertValue<T, long                >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(unsigned long*        value) const override { return convertValue<T, unsigned long       >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(long long*            value) const override { return convertValue<T, long long           >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(unsigned long long*   value) const override { return convertValue<T, unsigned long long  >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(float*                value) const override { return convertValue<T, float               >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(double*               value) const override { return convertValue<T, double              >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(long double*          value) const override { 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.
+        virtual inline bool getValue(bool*                 value) const override { return convertValue<T, bool                >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(void**                value) const override { return convertValue<T, void*               >(value, value_, nullptr); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(std::string*          value) const override { 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.
+        virtual inline bool getValue(orxonox::Vector2*     value) const override { 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.
+        virtual inline bool getValue(orxonox::Vector3*     value) const override { return convertValue<T, orxonox::Vector3    >(value, value_, NilValue<orxonox::Vector3>    ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(orxonox::Vector4*     value) const override { return convertValue<T, orxonox::Vector4    >(value, value_, NilValue<orxonox::Vector4>    ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(orxonox::ColourValue* value) const override { return convertValue<T, orxonox::ColourValue>(value, value_, NilValue<orxonox::ColourValue>()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(orxonox::Quaternion*  value) const override { return convertValue<T, orxonox::Quaternion >(value, value_, NilValue<orxonox::Quaternion> ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(orxonox::Radian*      value) const override { return convertValue<T, orxonox::Radian     >(value, value_, NilValue<orxonox::Radian>     ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(orxonox::Degree*      value) const override { return convertValue<T, orxonox::Degree     >(value, value_, NilValue<orxonox::Degree>     ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
 
         /**
@@ -91 +91 @@
             @param other The other MultiType
         */
-        inline bool setValue(const MultiType& other)
+        virtual inline bool setValue(const MultiType& other) override
         {
             if (other.value_)
@@ -104 +104 @@
         }
 
-        inline bool setValue(const char& value)                 { return (bLastConversionSuccessful = convertValue<char                , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const unsigned char& value)        { return (bLastConversionSuccessful = convertValue<unsigned char       , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const short& value)                { return (bLastConversionSuccessful = convertValue<short               , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const unsigned short& value)       { return (bLastConversionSuccessful = convertValue<unsigned short      , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const int& value)                  { return (bLastConversionSuccessful = convertValue<int                 , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const unsigned int& value)         { return (bLastConversionSuccessful = convertValue<unsigned int        , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const long& value)                 { return (bLastConversionSuccessful = convertValue<long                , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const unsigned long& value)        { return (bLastConversionSuccessful = convertValue<unsigned long       , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const long long& value)            { return (bLastConversionSuccessful = convertValue<long long           , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const unsigned long long& value)   { return (bLastConversionSuccessful = convertValue<unsigned long long  , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const float& value)                { return (bLastConversionSuccessful = convertValue<float               , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const double& value)               { return (bLastConversionSuccessful = convertValue<double              , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const long double& value)          { return (bLastConversionSuccessful = convertValue<long double         , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const bool& value)                 { return (bLastConversionSuccessful = convertValue<bool                , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(      void* const& value)          { return (bLastConversionSuccessful = convertValue<void*               , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const std::string& value)          { return (bLastConversionSuccessful = convertValue<std::string         , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const orxonox::Vector2& value)     { return (bLastConversionSuccessful = convertValue<orxonox::Vector2    , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const orxonox::Vector3& value)     { return (bLastConversionSuccessful = convertValue<orxonox::Vector3    , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const orxonox::Vector4& value)     { return (bLastConversionSuccessful = convertValue<orxonox::Vector4    , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const orxonox::ColourValue& value) { return (bLastConversionSuccessful = convertValue<orxonox::ColourValue, T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const orxonox::Quaternion& value)  { return (bLastConversionSuccessful = convertValue<orxonox::Quaternion , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const orxonox::Radian& value)      { return (bLastConversionSuccessful = convertValue<orxonox::Radian     , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const orxonox::Degree& value)      { return (bLastConversionSuccessful = convertValue<orxonox::Degree     , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const char& value)                 override { return (bLastConversionSuccessful = convertValue<char                , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const unsigned char& value)        override { return (bLastConversionSuccessful = convertValue<unsigned char       , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const short& value)                override { return (bLastConversionSuccessful = convertValue<short               , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const unsigned short& value)       override { return (bLastConversionSuccessful = convertValue<unsigned short      , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const int& value)                  override { return (bLastConversionSuccessful = convertValue<int                 , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const unsigned int& value)         override { return (bLastConversionSuccessful = convertValue<unsigned int        , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const long& value)                 override { return (bLastConversionSuccessful = convertValue<long                , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const unsigned long& value)        override { return (bLastConversionSuccessful = convertValue<unsigned long       , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const long long& value)            override { return (bLastConversionSuccessful = convertValue<long long           , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const unsigned long long& value)   override { return (bLastConversionSuccessful = convertValue<unsigned long long  , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const float& value)                override { return (bLastConversionSuccessful = convertValue<float               , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const double& value)               override { return (bLastConversionSuccessful = convertValue<double              , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const long double& value)          override { return (bLastConversionSuccessful = convertValue<long double         , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const bool& value)                 override { return (bLastConversionSuccessful = convertValue<bool                , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(      void* const& value)          override { return (bLastConversionSuccessful = convertValue<void*               , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const std::string& value)          override { return (bLastConversionSuccessful = convertValue<std::string         , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const orxonox::Vector2& value)     override { return (bLastConversionSuccessful = convertValue<orxonox::Vector2    , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const orxonox::Vector3& value)     override { return (bLastConversionSuccessful = convertValue<orxonox::Vector3    , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const orxonox::Vector4& value)     override { return (bLastConversionSuccessful = convertValue<orxonox::Vector4    , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const orxonox::ColourValue& value) override { return (bLastConversionSuccessful = convertValue<orxonox::ColourValue, T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const orxonox::Quaternion& value)  override { return (bLastConversionSuccessful = convertValue<orxonox::Quaternion , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const orxonox::Radian& value)      override { return (bLastConversionSuccessful = convertValue<orxonox::Radian     , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const orxonox::Degree& value)      override { return (bLastConversionSuccessful = convertValue<orxonox::Degree     , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
 
         /// Puts the current value on the stream
-        inline void toString(std::ostream& outstream) const { outstream << this->value_; }
+        virtual inline void toString(std::ostream& outstream) const override { outstream << this->value_; }
 
         /// loads data from the bytestream (mem) into the MT and increases the bytestream pointer by the size of the data
-        inline void importData( uint8_t*& mem )         { loadAndIncrease( /*(const T&)*/this->value_, mem ); }
+        virtual inline void importData( uint8_t*& mem ) override         { loadAndIncrease( /*(const T&)*/this->value_, mem ); }
         /// saves data from the MT into the bytestream (mem) and increases the bytestream pointer by the size of the data
-        inline void exportData( uint8_t*& mem ) const   { saveAndIncrease( /*(const T&)*/this->value_, mem ); }
+        virtual inline void exportData( uint8_t*& mem ) const override   { saveAndIncrease( /*(const T&)*/this->value_, mem ); }
         /// returns the size of the data that would be saved by exportData
-        inline uint8_t getSize() const { return returnSize( this->value_ ); }
+        virtual inline uint8_t getSize() const override { return returnSize( this->value_ ); }
 
         T value_; ///< The stored value

code/branches/cpp11_v3/src/libraries/util/Serialise.h

@@ -672 +672 @@
     {
         uint32_t tempsize = sizeof(uint32_t); // for the number of entries
-        for( typename std::set<T>::iterator it=((std::set<T>*)(&variable))->begin(); it!=((std::set<T>*)(&variable))->end(); ++it)
-            tempsize += returnSize( *it );
+        for(const T& element : *((std::set<T>*)(&variable)))
+            tempsize += returnSize( element );
         return tempsize;
     }
@@ -679 +679 @@
     template <class T> inline void saveAndIncrease(  const std::set<T>& variable, uint8_t*& mem )
     {
-        typename std::set<T>::const_iterator it = variable.begin();
         saveAndIncrease( (uint32_t)variable.size(), mem );
-        for( ; it!=variable.end(); ++it )
-            saveAndIncrease( *it, mem );
+        for( const T& elem : variable )
+            saveAndIncrease( elem, mem );
     }
 

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

@@ -44 +44 @@
 namespace orxonox
 {
-    SignalHandler* SignalHandler::singletonPtr_s = NULL;
+    SignalHandler* SignalHandler::singletonPtr_s = nullptr;
 }
 
@@ -81 +81 @@
     void SignalHandler::dontCatch()
     {
-      for ( SignalRecList::iterator it = sigRecList.begin(); it != sigRecList.end(); it++ )
-      {
-        signal( it->signal, it->handler );
+      for (const SignalRec& sigRec : sigRecList)
+      {
+        signal( sigRec.signal, sigRec.handler );
       }
 
@@ -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;
@@ -133 +133 @@
       }
 
-      for ( SignalCallbackList::iterator it = SignalHandler::getInstance().callbackList.begin(); it != SignalHandler::getInstance().callbackList.end(); it++  )
-      {
-        (*(it->cb))( it->someData );
+      for (const SignalCallbackRec& callback : SignalHandler::getInstance().callbackList)
+      {
+        (*(callback.cb))( callback.someData );
       }
 
@@ -175 +175 @@
         dup2( gdbErr[1], STDERR_FILENO );
 
-        execlp( "sh", "sh", "-c", "gdb", static_cast<void*>(NULL));
+        execlp( "sh", "sh", "-c", "gdb", static_cast<void*>(nullptr));
       }
 
@@ -186 +186 @@
         perror("pipe failed!\n");
         kill( gdbPid, SIGTERM );
-        waitpid( gdbPid, NULL, 0 );
+        waitpid( gdbPid, nullptr, 0 );
         exit(EXIT_FAILURE);
       }
@@ -196 +196 @@
         perror("fork failed!\n");
         kill( gdbPid, SIGTERM );
-        waitpid( gdbPid, NULL, 0 );
+        waitpid( gdbPid, nullptr, 0 );
         exit(EXIT_FAILURE);
       }
@@ -297 +297 @@
 
 
-      waitpid( sigPid, NULL, 0 );
-      waitpid( gdbPid, NULL, 0 );
+      waitpid( sigPid, nullptr, 0 );
+      waitpid( gdbPid, nullptr, 0 );
 
       int wsRemoved = 0;
@@ -312 +312 @@
         bt.erase(0, 1);
 
-      time_t now = time(NULL);
+      time_t now = time(nullptr);
 
       std::string timeString =
@@ -388 +388 @@
     SignalHandler::SignalHandler()
     {
-        this->prevExceptionFilter_ = NULL;
+        this->prevExceptionFilter_ = nullptr;
     }
 
@@ -394 +394 @@
     SignalHandler::~SignalHandler()
     {
-        if (this->prevExceptionFilter_ != NULL)
+        if (this->prevExceptionFilter_ != nullptr)
         {
             // Remove the unhandled exception filter function
             SetUnhandledExceptionFilter(this->prevExceptionFilter_);
-            this->prevExceptionFilter_ = NULL;
+            this->prevExceptionFilter_ = nullptr;
         }
     }
@@ -408 +408 @@
 
         // don't register twice
-        assert(this->prevExceptionFilter_ == NULL);
-
-        if (this->prevExceptionFilter_ == NULL)
+        assert(this->prevExceptionFilter_ == nullptr);
+
+        if (this->prevExceptionFilter_ == nullptr)
         {
             // Install the unhandled exception filter function
@@ -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;
@@ -441 +441 @@
             std::ofstream crashlog(SignalHandler::getInstance().filename_.c_str());
 
-            time_t now = time(NULL);
+            time_t now = time(nullptr);
 
             crashlog << "=======================================================" << endl;
@@ -480 +480 @@
     }
 
-    /// Returns the stack trace for either the current function, or, if @a pExceptionInfo is not NULL, for the given exception context.
+    /// Returns the stack trace for either the current function, or, if @a pExceptionInfo is not nullptr, for the given exception context.
     /* static */ std::string SignalHandler::getStackTrace(PEXCEPTION_POINTERS pExceptionInfo)
     {
@@ -625 +625 @@
 #ifdef ORXONOX_COMPILER_GCC
                 int status;
-                char* demangled = __cxxabiv1::__cxa_demangle(symbol->Name, NULL, NULL, &status);
+                char* demangled = __cxxabiv1::__cxa_demangle(symbol->Name, nullptr, nullptr, &status);
                 if (demangled)
                 {
@@ -684 +684 @@
         HMODULE hModule;
 
-        std::string output = (GetModuleFileName(NULL, szModule, MAX_PATH) ? SignalHandler::getModuleName(szModule) : "Application");
+        std::string output = (GetModuleFileName(nullptr, szModule, MAX_PATH) ? SignalHandler::getModuleName(szModule) : "Application");
         output += " caused ";
 

code/branches/cpp11_v3/src/libraries/util/SignalHandler.h

@@ -113 +113 @@
             void doCatch(const std::string& appName, const std::string& filename);
 
-            static std::string getStackTrace(PEXCEPTION_POINTERS pExceptionInfo = NULL);
+            static std::string getStackTrace(PEXCEPTION_POINTERS pExceptionInfo = nullptr);
             static std::string getExceptionType(PEXCEPTION_POINTERS pExceptionInfo);
 

code/branches/cpp11_v3/src/libraries/util/Singleton.h

@@ -66 +66 @@
     And don't forget to initialize the static singleton pointer in the source (*.cc) %file:
     @code
-    TestSingleton* TestSingleton::singletonPtr_s = NULL;
+    TestSingleton* TestSingleton::singletonPtr_s = nullptr;
     @endcode
 
@@ -118 +118 @@
         static T& getInstance()
         {
-            OrxVerify(T::singletonPtr_s != NULL, "T=" << typeid(T).name());
+            OrxVerify(T::singletonPtr_s != nullptr, "T=" << typeid(T).name());
             return *T::singletonPtr_s;
         }
@@ -125 +125 @@
         static bool exists()
         {
-            return (T::singletonPtr_s != NULL);
+            return (T::singletonPtr_s != nullptr);
         }
 
@@ -132 +132 @@
         Singleton()
         {
-            OrxVerify(T::singletonPtr_s == NULL, "T=" << typeid(T).name());
+            OrxVerify(T::singletonPtr_s == nullptr, "T=" << typeid(T).name());
             T::singletonPtr_s = static_cast<T*>(this);
         }
@@ -139 +139 @@
         virtual ~Singleton()
         {
-            OrxVerify(T::singletonPtr_s != NULL, "T=" << typeid(T).name());
-            T::singletonPtr_s = NULL;
+            OrxVerify(T::singletonPtr_s != nullptr, "T=" << typeid(T).name());
+            T::singletonPtr_s = nullptr;
         }
 
     private:
-        Singleton(const Singleton& rhs); //!< Don't use (undefined)
+        // non-copyable:
+        Singleton(const Singleton&) = delete;
+        Singleton& operator=(const Singleton&) = delete;
     };
 }

code/branches/cpp11_v3/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;
     }
 
@@ -53 +53 @@
     SmallObjectAllocator::~SmallObjectAllocator()
     {
-        for (std::vector<char*>::iterator it = this->blocks_.begin(); it != this->blocks_.end(); ++it)
-            delete[] *it;
+        for (char* block : this->blocks_)
+            delete[] block;
     }
 
@@ -97 +97 @@
                 setNext(block + i * this->chunkSize_, block + (i + 1) * this->chunkSize_);
 
-            // the next_ pointer of the last chunk must point to NULL
-            setNext(block + (this->numChunksPerBlock_ - 1) * this->chunkSize_, 0);
+            // the next_ pointer of the last chunk must point to nullptr
+            setNext(block + (this->numChunksPerBlock_ - 1) * this->chunkSize_, nullptr);
 
             // The second chunk in the block is assigned to the first_ pointer

code/branches/cpp11_v3/src/libraries/util/SmallObjectAllocator.h

@@ -77 +77 @@
 #include "UtilPrereqs.h"
 #include <vector>
+#include <cstdio>
 
 namespace orxonox

code/branches/cpp11_v3/src/libraries/util/StringUtils.cc

@@ -36 +36 @@
 #include <cctype>
 #include <ctime>
-#include <boost/scoped_array.hpp>
 #include "Convert.h"
 #include "Math.h"
@@ -263 +262 @@
         std::string output(str.size() * 2, ' ');
         size_t i = 0;
-        for (size_t pos = 0; pos < str.size(); ++pos)
-        {
-            switch (str[pos])
+        for (const char& character : str)
+        {
+            switch (character)
             {
             case '\\': output[i] = '\\'; output[i + 1] = '\\'; break;
@@ -277 +276 @@
             case  '"': output[i] = '\\'; output[i + 1] =  '"'; break;
             case '\0': output[i] = '\\'; output[i + 1] =  '0'; break;
-            default  : output[i] = str[pos]; ++i; continue;
+            default  : output[i] = character; ++i; continue;
             }
             i += 2;
@@ -337 +336 @@
     void lowercase(std::string* str)
     {
-        for (size_t i = 0; i < str->size(); ++i)
-        {
-            (*str)[i] = static_cast<char>(tolower((*str)[i]));
+        for (char& character : *str)
+        {
+            character = static_cast<char>(tolower(character));
         }
     }
@@ -354 +353 @@
     void uppercase(std::string* str)
     {
-        for (size_t i = 0; i < str->size(); ++i)
-        {
-            (*str)[i] = static_cast<char>(toupper((*str)[i]));
+        for (char& character : *str)
+        {
+            character = static_cast<char>(toupper(character));
         }
     }
@@ -461 +460 @@
     {
         size_t j = 0;
-        for (size_t i = 0; i < str.size(); ++i)
-        {
-            if (str[i] == target)
+        for (char& character : str)
+        {
+            if (character == target)
             {
-                str[i] = replacement;
+                character = replacement;
                 ++j;
             }
@@ -482 +481 @@
         size_t cols = str1.size() + 1;
         size_t rows = str2.size() + 1;
-        boost::scoped_array<int> matrix(new int[rows * cols]);
+        const std::unique_ptr<int[]> matrix(new int[rows * cols]);
 
         for (size_t r = 0; r < rows; ++r)

code/branches/cpp11_v3/src/libraries/util/SubString.cc

@@ -112 +112 @@
         for (size_t i = 0; i < argc; ++i)
         {
-            this->tokens_.push_back(std::string(argv[i]));
+            this->tokens_.emplace_back(argv[i]);
             this->bTokenInSafemode_.push_back(false);
         }

code/branches/cpp11_v3/src/libraries/util/UtilPrereqs.h

@@ -80 +80 @@
     class OutputStream;
     class ScopeListener;
-    template <class T>
-    class SharedPtr;
     class SignalHandler;
     template <class T>

code/branches/cpp11_v3/src/libraries/util/output/BaseWriter.cc

@@ -47 +47 @@
         this->configurableMaxLevel_ = level::none;
         this->configurableAdditionalContextsMaxLevel_ = level::verbose;
-        this->configurableAdditionalContexts_.push_back("example");
+        this->configurableAdditionalContexts_.emplace_back("example");
 
         this->changedConfigurableLevel();
@@ -116 +116 @@
 
         // iterate over all strings in the config-vector
-        for (size_t i = 0; i < this->configurableAdditionalContexts_.size(); ++i)
+        for (const std::string& full_name : this->configurableAdditionalContexts_)
         {
-            const std::string& full_name = this->configurableAdditionalContexts_[i];
-
             // split the name into main-name and sub-name (if given; otherwise sub-name remains empty). both names are separated by ::
             std::string name = full_name;

code/branches/cpp11_v3/src/libraries/util/output/BaseWriter.h

@@ -103 +103 @@
 
         protected:
-            virtual void output(OutputLevel level, const OutputContextContainer& context, const std::vector<std::string>& lines);
+            virtual void output(OutputLevel level, const OutputContextContainer& context, const std::vector<std::string>& lines) override;
 
         private:

code/branches/cpp11_v3/src/libraries/util/output/ConsoleWriter.h

@@ -53 +53 @@
         public:
             ConsoleWriter(std::ostream& outputStream);
-            ConsoleWriter(const ConsoleWriter&);
             virtual ~ConsoleWriter();
 
@@ -63 +62 @@
 
         protected:
-            virtual void printLine(const std::string& line, OutputLevel level);
+            virtual void printLine(const std::string& line, OutputLevel level) override;
 
         private:
+            // non-copyable:
+            ConsoleWriter(const ConsoleWriter&) = delete;
+            ConsoleWriter& operator=(const ConsoleWriter&) = delete;
+
             std::ostream& outputStream_; ///< The ostream to which the console writer writes its output
             bool bEnabled_;              ///< If false, the instance will not write output to the console.

code/branches/cpp11_v3/src/libraries/util/output/LogWriter.cc

@@ -35 +35 @@
 
 #include <ctime>
+#include <chrono>
 #include <cstdlib>
 
@@ -43 +44 @@
 namespace orxonox
 {
-    static const int MAX_ARCHIVED_FILES = 9;
+    static constexpr int MAX_ARCHIVED_FILES = 9;
 
     /**
@@ -180 +181 @@
             return;
 
+        // get the milliseconds
+        std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
+        std::chrono::system_clock::duration timeSinceEpoch = now.time_since_epoch();
+        std::chrono::milliseconds millisSinceEpoch = std::chrono::duration_cast<std::chrono::milliseconds>(timeSinceEpoch);
+        unsigned int millis = (millisSinceEpoch.count() % 1000);
+
         // get the current time
-        time_t rawtime;
-        struct tm* timeinfo;
-        time(&rawtime);
-        timeinfo = localtime(&rawtime);
+        time_t rawtime = std::chrono::system_clock::to_time_t(now);
+        struct tm* timeinfo = localtime(&rawtime);
+
+        // format time: hh:mm:ss:xxx
+        char buffer[13];
+        snprintf(buffer, sizeof(buffer), "%.2i:%.2i:%.2i:%.3i", timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec, millis);
 
         // print timestamp and output line to the log file
-        this->file_ << (timeinfo->tm_hour < 10 ? "0" : "") << timeinfo->tm_hour << ':' <<
-                       (timeinfo->tm_min  < 10 ? "0" : "") << timeinfo->tm_min  << ':' <<
-                       (timeinfo->tm_sec  < 10 ? "0" : "") << timeinfo->tm_sec  << ' ' << line << std::endl;
+        this->file_ << buffer << ' ' << line << std::endl;
     }
 }

code/branches/cpp11_v3/src/libraries/util/output/LogWriter.h

@@ -57 +57 @@
         public:
             LogWriter();
-            LogWriter(const LogWriter&);
             virtual ~LogWriter();
 
@@ -70 +69 @@
 
         protected:
-            virtual void printLine(const std::string& line, OutputLevel level);
+            virtual void printLine(const std::string& line, OutputLevel level) override;
 
         private:
+            // non-copyable:
+            LogWriter(const LogWriter&) = delete;
+            LogWriter& operator=(const LogWriter&) = delete;
+
             void openFile();
             void closeFile();

code/branches/cpp11_v3/src/libraries/util/output/MemoryWriter.cc

@@ -57 +57 @@
     void MemoryWriter::output(OutputLevel level, const OutputContextContainer& context, const std::vector<std::string>& lines)
     {
-        this->messages_.push_back(Message(level, context, lines));
+        this->messages_.emplace_back(level, context, lines);
     }
 
@@ -65 +65 @@
     void MemoryWriter::resendOutput(OutputListener* listener) const
     {
-        for (size_t i = 0; i < this->messages_.size(); ++i)
+        for (const Message& message : this->messages_)
         {
-            const Message& message = this->messages_[i];
             listener->unfilteredOutput(message.level, *message.context, message.lines);
         }

code/branches/cpp11_v3/src/libraries/util/output/MemoryWriter.h

@@ -68 +68 @@
         public:
             MemoryWriter();
-            MemoryWriter(const MemoryWriter&);
             virtual ~MemoryWriter();
 
@@ -75 +74 @@
 
         protected:
-            virtual void output(OutputLevel level, const OutputContextContainer& context, const std::vector<std::string>& lines);
+            virtual void output(OutputLevel level, const OutputContextContainer& context, const std::vector<std::string>& lines) override;
 
         private:
+            // non-copyable:
+            MemoryWriter(const MemoryWriter&) = delete;
+            MemoryWriter& operator=(const MemoryWriter&) = delete;
+
             std::vector<Message> messages_; ///< Stores all output messages from the creation of this instance until disable() is called.
     };

code/branches/cpp11_v3/src/libraries/util/output/OutputDefinitions.h

@@ -132 +132 @@
     namespace context
     {
-        static const OutputContextMask all       = 0xFFFFFFFFFFFFFFFFull; ///< Context mask, all bits set to 1
-        static const OutputContextMask none      = 0x0000000000000000ull; ///< Context mask, all bits set to 0
+        static constexpr OutputContextMask all       = 0xFFFFFFFFFFFFFFFFull; ///< Context mask, all bits set to 1
+        static constexpr OutputContextMask none      = 0x0000000000000000ull; ///< Context mask, all bits set to 0
 
-        static const OutputContextSubID no_subcontext = 0; ///< Used as ID for contexts which are not sub-contexts
+        static constexpr OutputContextSubID no_subcontext = 0; ///< Used as ID for contexts which are not sub-contexts
 
         namespace

code/branches/cpp11_v3/src/libraries/util/output/OutputListener.cc

@@ -111 +111 @@
         this->levelMask_ = mask;
 
-        for (size_t i = 0; i < this->listeners_.size(); ++i)
-            this->listeners_[i]->updatedLevelMask(this);
+        for (AdditionalContextListener* listener : this->listeners_)
+            listener->updatedLevelMask(this);
     }
 
@@ -142 +142 @@
         this->additionalContextsLevelMask_ = mask;
 
-        for (size_t i = 0; i < this->listeners_.size(); ++i)
-            this->listeners_[i]->updatedAdditionalContextsLevelMask(this);
+        for (AdditionalContextListener* listener : this->listeners_)
+            listener->updatedAdditionalContextsLevelMask(this);
     }
 
@@ -153 +153 @@
         this->additionalContextsMask_ = mask;
 
-        for (size_t i = 0; i < this->listeners_.size(); ++i)
-            this->listeners_[i]->updatedAdditionalContextsMask(this);
+        for (AdditionalContextListener* listener : this->listeners_)
+            listener->updatedAdditionalContextsMask(this);
     }
 

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

@@ -41 +41 @@
 #include "util/Output.h"
 #include "util/StringUtils.h"
-#include "util/SharedPtr.h"
 
 namespace orxonox
@@ -57 +56 @@
 
         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
@@ -81 +80 @@
     }
 
-    /*static*/ SharedPtr<OutputManager>& OutputManager::Testing::getInstancePointer()
-    {
-        static SharedPtr<OutputManager> instance(new OutputManager());
+    /*static*/ std::shared_ptr<OutputManager>& OutputManager::Testing::getInstancePointer()
+    {
+        static std::shared_ptr<OutputManager> instance(new OutputManager());
         return instance;
     }
@@ -132 +131 @@
         vectorize(message, '\n', &lines);
 
-        for (size_t i = 0; i < this->listeners_.size(); ++i)
-            this->listeners_[i]->unfilteredOutput(level, context, lines);
+        for (OutputListener* listener : this->listeners_)
+            listener->unfilteredOutput(level, context, lines);
     }
 
@@ -179 +178 @@
     {
         int mask = 0;
-        for (size_t i = 0; i < this->listeners_.size(); ++i)
-            mask |= this->listeners_[i]->getLevelMask();
+        for (OutputListener* listener : this->listeners_)
+            mask |= listener->getLevelMask();
         this->combinedLevelMask_ = static_cast<OutputLevel>(mask);
     }
@@ -190 +189 @@
     {
         int mask = 0;
-        for (size_t i = 0; i < this->listeners_.size(); ++i)
-            mask |= this->listeners_[i]->getAdditionalContextsLevelMask();
+        for (OutputListener* listener : this->listeners_)
+            mask |= listener->getAdditionalContextsLevelMask();
         this->combinedAdditionalContextsLevelMask_ = static_cast<OutputLevel>(mask);
     }
@@ -201 +200 @@
     {
         this->combinedAdditionalContextsMask_ = 0;
-        for (size_t i = 0; i < this->listeners_.size(); ++i)
-            this->combinedAdditionalContextsMask_ |= this->listeners_[i]->getAdditionalContextsMask();
+        for (OutputListener* listener : this->listeners_)
+            this->combinedAdditionalContextsMask_ |= listener->getAdditionalContextsMask();
     }
 

code/branches/cpp11_v3/src/libraries/util/output/OutputManager.h

@@ -41 +41 @@
 #include <vector>
 #include <map>
+#include <memory>
 
 #include "OutputDefinitions.h"
@@ -66 +67 @@
         public:
             OutputManager();
-            OutputManager(const OutputManager&);
             virtual ~OutputManager();
 
@@ -81 +81 @@
             virtual void unregisterListener(OutputListener* listener);
 
-            virtual void updatedLevelMask(const OutputListener* listener)
+            virtual void updatedLevelMask(const OutputListener* listener) override
                 { this->updateCombinedLevelMask(); }
-            virtual void updatedAdditionalContextsLevelMask(const OutputListener* listener)
+            virtual void updatedAdditionalContextsLevelMask(const OutputListener* listener) override
                 { this->updateCombinedAdditionalContextsLevelMask(); }
-            virtual void updatedAdditionalContextsMask(const OutputListener* listener)
+            virtual void updatedAdditionalContextsMask(const OutputListener* listener) override
                 { this->updateCombinedAdditionalContextsMask(); }
 
@@ -114 +114 @@
 
         private:
+            // non-copyable:
+            OutputManager(const OutputManager&) = delete;
+            OutputManager& operator=(const OutputManager&) = delete;
+
             void updateMasks();
             void updateCombinedLevelMask();
@@ -137 +141 @@
             struct _UtilExport Testing
             {
-                static SharedPtr<OutputManager>& getInstancePointer();
+                static std::shared_ptr<OutputManager>& getInstancePointer();
             };
     };

code/branches/cpp11_v3/src/libraries/util/output/OutputStream.cc

@@ -41 +41 @@
         @brief Default constructor, initializes level and context with default values.
     */
-    OutputStream::OutputStream()
+    OutputStream::OutputStream() : OutputStream(level::debug_output, context::undefined())
     {
-        this->setOutputAttributes(level::debug_output, context::undefined());
     }
 

code/branches/cpp11_v3/src/libraries/util/output/SubcontextOutputListener.cc

@@ -79 +79 @@
 
         // compose the mask of subcontexts and build the set of sub-context-IDs
-        for (std::set<const OutputContextContainer*>::const_iterator it = subcontexts.begin(); it != subcontexts.end(); ++it)
+        for (const OutputContextContainer* subcontext : subcontexts)
         {
-            this->subcontextsCheckMask_ |= (*it)->mask;
-            this->subcontexts_.insert((*it)->sub_id);
+            this->subcontextsCheckMask_ |= subcontext->mask;
+            this->subcontexts_.insert(subcontext->sub_id);
         }
 

code/branches/cpp11_v3/src/libraries/util/output/SubcontextOutputListener.h

@@ -73 +73 @@
             virtual ~SubcontextOutputListener();
 
-            virtual void setAdditionalContextsMask(OutputContextMask mask);
+            virtual void setAdditionalContextsMask(OutputContextMask mask) override;
             void setAdditionalSubcontexts(const std::set<const OutputContextContainer*>& subcontexts);
 
-            virtual bool acceptsOutput(OutputLevel level, const OutputContextContainer& context) const;
+            virtual bool acceptsOutput(OutputLevel level, const OutputContextContainer& context) const override;
 
             inline const std::set<OutputContextSubID>& getSubcontexts() const