Context Navigation

cpp11_v2

Timestamp:

Nov 22, 2015, 5:26:10 PM (9 years ago)

Author:

landauf

Message:

updated documentation

Location:

code/branches/cpp11_v2/src/libraries/core

Files:

-                      r10825
+                      r10828
     orxonox::Executor is used to wrap an orxonox::Functor and to store default values for
     its parameters. Usually one uses the function createExecutor() to create a new executor.
     This function returns an orxonox::ExecutorPtr which is a typedef of @ref orxonox::SharedPtr
     "SharedPtr<Executor>", used to manage the pointer to the executor.
+    This function returns an orxonox::ExecutorPtr which is a typedef of "std::shared_ptr<Executor>",
+    used to manage the pointer to the executor.
     Executors are mostly used to execute callbacks. Because some callback functions need arguments,
 …
     @endcode
     Because executors that were created with createExecutor() are managed by an orxonox::SharedPtr,
     they don't need to be deleted after usage.
+    Executors don't need to be deleted after usage normally because they are managed by an
+    std::shared_ptr when they were created with createExecutor().
 */

-                      r10825
+                      r10828
     @brief Typedefs and definitions of ExecutorPtr, ExecutorStaticPtr, and ExecutorMemberPtr
     Instances of orxonox::Executor are usually managed by an orxonox::SharedPtr. This ensures
+    Instances of orxonox::Executor are usually managed by an std::shared_ptr. This ensures
     that Executors will be destroyed after usage. To make things easier, there's a typedef
     that defines ExecutorPtr as SharedPtr<Executor>.
+    that defines ExecutorPtr as std::shared_ptr<Executor>.
     Because there's not only orxonox::Executor, but also orxonox::ExecutorStatic, and

-                      r10825
+                      r10828
     To create a Functor, the helper function createFunctor() is used. It returns an instance
     of orxonox::FunctorPtr which is simply a typedef of @ref orxonox::SharedPtr "SharedPtr<Functor>".
     This means you don't have to delete the Functor after using it, because it is managed
     by the SharedPtr.
+    of orxonox::FunctorPtr which is simply a typedef of "std::shared_ptr<Functor>". This
+    means you don't have to delete the Functor after using it, because it is managed
+    by the std::shared_ptr.
     Example:

-                      r10825
+                      r10828
     @brief Typedefs and definitions of FunctorPtr, FunctorMemberPtr, FunctorStaticPtr, and FunctorPointerPtr
     Instances of orxonox::Functor are usually managed by an orxonox::SharedPtr. This ensures
+    Instances of orxonox::Functor are usually managed by an std::shared_ptr. This ensures
     that Functors will be destroyed after usage. To make things easier, there's a typedef
     that defines FunctorPtr as SharedPtr<Functor>.
+    that defines FunctorPtr as std::shared_ptr<Functor>.
     Because there's not only orxonox::Functor, but also orxonox::FunctorStatic, and

-                      r10770
+                      r10828
     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
+    In contrast to std::shared_ptr, 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.
 …
     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 StrongPtr (in
     contrast to SharedPtr).
+    contrast to std::shared_ptr).
     @b Important: If you want to delete an object, you must not use @c delete @c object but

Note: See TracChangeset for help on using the changeset viewer.