Index: code/branches/core7/src/libraries/core/object/StrongPtr.h
===================================================================
--- code/branches/core7/src/libraries/core/object/SmartPtr.h	(revision 10358)
+++ code/branches/core7/src/libraries/core/object/StrongPtr.h	(revision 10555)
@@ -30,5 +30,5 @@
 
 /**
-    @defgroup SmartPtr SmartPtr<T> and WeakPtr<T>
+    @defgroup SmartPtr StrongPtr<T> and WeakPtr<T>
     @ingroup Object
 */
@@ -37,27 +37,27 @@
     @file
     @ingroup Object SmartPtr
-    @brief Definition of SmartPtr<T>, wraps a pointer to an object and keeps it alive.
-
-    @anchor SmartPtrExample
-
-    orxonox::SmartPtr is an implementation of a smart pointer - it wraps a pointer to an
-    object  and keeps this object alive until no SmartPtr points to this object anymore.
-    In contrast to orxonox::SharedPtr, SmartPtr works only with classes that are derived
+    @brief Definition of StrongPtr<T>, wraps a pointer to an object and keeps it alive.
+
+    @anchor StrongPtrExample
+
+    orxonox::StrongPtr is an implementation of a smart pointer - it wraps a pointer to an
+    object  and keeps this object alive until no StrongPtr points to this object anymore.
+    In contrast to orxonox::SharedPtr, StrongPtr works only with classes that are derived
     from orxonox::Destroyable, because it's an intrusive implementation, meaning the
     reference counter is stored in the object itself.
 
-    It's possible to use normal pointers and smart pointers to an object simultaneously.
-    You don't have to use SmartPtr all the time, you can create a SmartPtr for an object
+    It's possible to use normal pointers and strong pointers to an object simultaneously.
+    You don't have to use StrongPtr all the time, you can create a StrongPtr for an object
     at any time and also convert it back to a normal pointer if you like. This is possible
-    because the reference counter is stored in the object itself and not in SmartPtr (in
+    because the reference counter is stored in the object itself and not in StrongPtr (in
     contrast to SharedPtr).
 
     @b Important: If you want to delete an object, you must not use @c delete @c object but
-    rather @c object->destroy(). This function will check if there are smart pointers
-    pointing to the object. If yes, the object will be kept alive until all smart pointes
+    rather @c object->destroy(). This function will check if there are strong pointers
+    pointing to the object. If yes, the object will be kept alive until all strong pointers
     are destroyed. If no, the object is deleted instantly.
 
-    If all smart pointers that point to an object are destroyed, but you never called
-    @c object->destroy() before, the object will not be deleted! All a SmartPtr will do
+    If all strong pointers that point to an object are destroyed, but you never called
+    @c object->destroy() before, the object will not be deleted! All a StrongPtr will do
     is to really just keep an object alive, but it will not delete it automatically
     unless you tried to destroy it before.
@@ -68,12 +68,12 @@
     {
         public:
-            void setObject(OtherClass* object)              // passes a normal pointer which will be stored in a SmartPtr
+            void setObject(OtherClass* object)              // passes a normal pointer which will be stored in a StrongPtr
                 { this->object_ = object; }
 
-            OtherClass* getObject() const                   // converts the SmartPtr to a normal pointer and returns it
+            OtherClass* getObject() const                   // converts the StrongPtr to a normal pointer and returns it
                 { return this->object_; }
 
         private:
-            SmartPtr<OtherClass> object_;                   // a pointer to an instance of OtherClass is stored in a SmartPtr
+            StrongPtr<OtherClass> object_;                  // a pointer to an instance of OtherClass is stored in a StrongPtr
     };
     @endcode
@@ -85,13 +85,13 @@
     MyClass* myclass = new MyClass();                       // create an instance of MyClass
     OtherClass* object = new OtherClass();                  // create an instance of OtherClass
-    myclass->setObject(object);                             // the object is now stored in a SmartPtr inside myclass
-
-    object->destroy();                                      // we try to destroy object, but there's still a SmartPtr pointing at it.
-
-    # object still exists at this point (because a SmartPtr points at it)
-
-    delete myclass;                                         // now we delete myclass, which also destroys the SmartPtr
-
-    # object doesn't exist anymore (because the SmartPtr is now destroyed)
+    myclass->setObject(object);                             // the object is now stored in a StrongPtr inside myclass
+
+    object->destroy();                                      // we try to destroy object, but there's still a StrongPtr pointing at it.
+
+    # object still exists at this point (because a StrongPtr points at it)
+
+    delete myclass;                                         // now we delete myclass, which also destroys the StrongPtr
+
+    # object doesn't exist anymore (because the StrongPtr is now destroyed)
     @endcode
 
@@ -100,7 +100,7 @@
     MyClass* myclass = new MyClass();                       // create an instance of MyClass
     OtherClass* object = new OtherClass();                  // create an instance of OtherClass
-    myclass->setObject(object);                             // the object is now stored in a SmartPtr inside myclass
-
-    delete myclass;                                         // we delete myclass, which also destroys the SmartPtr
+    myclass->setObject(object);                             // the object is now stored in a StrongPtr inside myclass
+
+    delete myclass;                                         // we delete myclass, which also destroys the StrongPtr
 
     # object still exists at this point (because destroy() was not called yet)
@@ -112,10 +112,10 @@
 
     Note that in any case @c object->destroy() has to be called to delete the object.
-    However if a SmartPtr points at it, the destruction is delayed until all SmartPtr
+    However if a StrongPtr points at it, the destruction is delayed until all StrongPtr
     are destroyed.
 */
 
-#ifndef _SmartPtr_H__
-#define _SmartPtr_H__
+#ifndef _StrongPtr_H__
+#define _StrongPtr_H__
 
 #include "core/CorePrereqs.h"
@@ -129,19 +129,19 @@
 {
     /**
-        @brief A smart pointer which wraps a pointer to an object and keeps this object alive as long as the smart pointer exists.
-
-        @see See @ref SmartPtrExample "this description" for more information and an example.
+        @brief A strong pointer which wraps a pointer to an object and keeps this object alive as long as the strong pointer exists.
+
+        @see See @ref StrongPtrExample "this description" for more information and an example.
     */
     template <class T>
-    class SmartPtr
+    class StrongPtr
     {
         public:
-            /// Constructor: Initializes the smart pointer with a null pointer.
-            inline SmartPtr() : pointer_(0), base_(0)
-            {
-            }
-
-            /// Constructor: Initializes the smart pointer with a pointer to an object. @param pointer The pointer @param bAddRef If true, the reference counter is increased. Don't set this to false unless you know exactly what you're doing! (for example to avoid circular references if the @c this pointer of the possessing object is stored)
-            inline SmartPtr(T* pointer, bool bAddRef = true) : pointer_(pointer), base_(pointer)
+            /// Constructor: Initializes the strong pointer with a null pointer.
+            inline StrongPtr() : pointer_(0), base_(0)
+            {
+            }
+
+            /// Constructor: Initializes the strong pointer with a pointer to an object. @param pointer The pointer @param bAddRef If true, the reference counter is increased. Don't set this to false unless you know exactly what you're doing! (for example to avoid circular references if the @c this pointer of the possessing object is stored)
+            inline StrongPtr(T* pointer, bool bAddRef = true) : pointer_(pointer), base_(pointer)
             {
                 if (this->base_ && bAddRef)
@@ -150,5 +150,5 @@
 
             /// Copy-constructor
-            inline SmartPtr(const SmartPtr& other) : pointer_(other.pointer_), base_(other.base_)
+            inline StrongPtr(const StrongPtr& other) : pointer_(other.pointer_), base_(other.base_)
             {
                 if (this->base_)
@@ -156,7 +156,7 @@
             }
 
-            /// Copy-constructor for smart pointers to objects of another class.
+            /// Copy-constructor for strong pointers to objects of another class.
             template <class O>
-            inline SmartPtr(const SmartPtr<O>& other) : pointer_(other.get()), base_(other.base_)
+            inline StrongPtr(const StrongPtr<O>& other) : pointer_(other.get()), base_(other.base_)
             {
                 if (this->base_)
@@ -164,7 +164,7 @@
             }
 
-            /// Constructor: Initializes the smart pointer with the pointer that is stored in a WeakPtr.
+            /// Constructor: Initializes the strong pointer with the pointer that is stored in a WeakPtr.
             template <class O>
-            inline SmartPtr(const WeakPtr<O>& other) : pointer_(other.get()), base_(other.getBase())
+            inline StrongPtr(const WeakPtr<O>& other) : pointer_(other.get()), base_(other.getBase())
             {
                 if (this->base_)
@@ -173,5 +173,5 @@
 
             /// Destructor: Decrements the reference counter.
-            inline ~SmartPtr()
+            inline ~StrongPtr()
             {
                 if (this->base_)
@@ -180,22 +180,22 @@
 
             /// Assigns a new pointer.
-            inline SmartPtr& operator=(T* pointer)
-            {
-                SmartPtr(pointer).swap(*this);
+            inline StrongPtr& operator=(T* pointer)
+            {
+                StrongPtr(pointer).swap(*this);
                 return *this;
             }
 
-            /// Assigns the wrapped pointer of another SmartPtr.
-            inline SmartPtr& operator=(const SmartPtr& other)
-            {
-                SmartPtr(other).swap(*this);
+            /// Assigns the wrapped pointer of another StrongPtr.
+            inline StrongPtr& operator=(const StrongPtr& other)
+            {
+                StrongPtr(other).swap(*this);
                 return *this;
             }
 
-            /// Assigns the wrapped pointer of a SmartPtr of another class
+            /// Assigns the wrapped pointer of a StrongPtr of another class
             template <class O>
-            inline SmartPtr& operator=(const SmartPtr<O>& other)
-            {
-                SmartPtr(other).swap(*this);
+            inline StrongPtr& operator=(const StrongPtr<O>& other)
+            {
+                StrongPtr(other).swap(*this);
                 return *this;
             }
@@ -203,7 +203,7 @@
             /// Assigns the wrapped pointer of a WeakPtr.
             template <class O>
-            inline SmartPtr& operator=(const WeakPtr<O>& other)
-            {
-                SmartPtr(other).swap(*this);
+            inline StrongPtr& operator=(const WeakPtr<O>& other)
+            {
+                StrongPtr(other).swap(*this);
                 return *this;
             }
@@ -221,5 +221,5 @@
             }
 
-            /// Implicitly converts the SmartPtr to a pointer of type @c T*
+            /// Implicitly converts the StrongPtr to a pointer of type @c T*
             inline operator T*() const
             {
@@ -247,6 +247,6 @@
             }
 
-            /// Swaps the contents of two smart pointers.
-            inline void swap(SmartPtr& other)
+            /// Swaps the contents of two strong pointers.
+            inline void swap(StrongPtr& other)
             {
                 {
@@ -262,39 +262,39 @@
             }
 
-            /// Resets the smart pointer (equivalent to assigning a NULL pointer).
+            /// Resets the strong pointer (equivalent to assigning a NULL pointer).
             inline void reset()
             {
-                SmartPtr().swap(*this);
+                StrongPtr().swap(*this);
             }
 
         private:
             T* pointer_;            ///< The wrapped pointer to an object of type @a T
-            Destroyable* base_;    ///< The wrapped pointer, casted up to Destroyable (this is needed because with just a T* pointer, SmartPtr couln't be used with forward declarations)
+            Destroyable* base_;    ///< The wrapped pointer, casted up to Destroyable (this is needed because with just a T* pointer, StrongPtr couln't be used with forward declarations)
     };
 
-    /// Swaps the contents of two smart pointers.
+    /// Swaps the contents of two strong pointers.
     template <class T>
-    void swap(SmartPtr<T>& a, SmartPtr<T>& b)
+    void swap(StrongPtr<T>& a, StrongPtr<T>& b)
     {
         a.swap(b);
     }
 
-    /// Uses a static_cast to cast a pointer of type U* to a pointer of type T* and returns it in a new SmartPtr<T>.
+    /// Uses a static_cast to cast a pointer of type U* to a pointer of type T* and returns it in a new StrongPtr<T>.
     template <class T, class U>
-    SmartPtr<T> static_pointer_cast(const SmartPtr<U>& p)
+    StrongPtr<T> static_pointer_cast(const StrongPtr<U>& p)
     {
         return static_cast<T*>(p.get());
     }
 
-    /// Uses a const_cast to cast a pointer of type U* to a pointer of type T* and returns it in a new SmartPtr<T>.
+    /// Uses a const_cast to cast a pointer of type U* to a pointer of type T* and returns it in a new StrongPtr<T>.
     template <class T, class U>
-    SmartPtr<T> const_pointer_cast(const SmartPtr<U>& p)
+    StrongPtr<T> const_pointer_cast(const StrongPtr<U>& p)
     {
         return const_cast<T*>(p.get());
     }
 
-    /// Uses a dynamic_cast to cast a pointer of type U* to a pointer of type T* and returns it in a new SmartPtr<T>.
+    /// Uses a dynamic_cast to cast a pointer of type U* to a pointer of type T* and returns it in a new StrongPtr<T>.
     template <class T, class U>
-    SmartPtr<T> dynamic_pointer_cast(const SmartPtr<U>& p)
+    StrongPtr<T> dynamic_pointer_cast(const StrongPtr<U>& p)
     {
         return orxonox_cast<T*>(p.get());
@@ -302,3 +302,3 @@
 }
 
-#endif /* _SmartPtr_H__ */
+#endif /* _StrongPtr_H__ */
