Fix Doxygen errors

Author: foonathan

include/foonathan/memory/allocator_storage.hpp

@@ -241,7 +241,7 @@ namespace foonathan
             /// The \c Mutex will be locked during the operation.
             /// \requires The allocator must be composable,
             /// i.e. \ref is_composable() must return `true`.
-            /// \notes This check is done at compile-time where possible,
+            /// \note This check is done at compile-time where possible,
             /// and at runtime in the case of type-erased storage.
             FOONATHAN_ENABLE_IF(composable::value)
             void* try_allocate_node(std::size_t size, std::size_t alignment) FOONATHAN_NOEXCEPT
@@ -322,7 +322,7 @@ namespace foonathan
 
             /// \returns Whether or not the stored allocator is composable,
             /// that is you can use the compositioning functions.
-            /// \notes Due to type-erased allocators,
+            /// \note Due to type-erased allocators,
             /// this function can not be `constexpr`.
             bool is_composable() const FOONATHAN_NOEXCEPT
             {

include/foonathan/memory/fallback_allocator.hpp

@@ -5,6 +5,9 @@
 #ifndef FOONATHAN_MEMORY_FALLBACK_ALLOCATOR_HPP_INCLUDED
 #define FOONATHAN_MEMORY_FALLBACK_ALLOCATOR_HPP_INCLUDED
 
+/// \file
+//// Class template \ref foonathan::memory::fallback_allocator.
+
 #include "detail/ebo_storage.hpp"
 #include "detail/utility.hpp"
 #include "allocator_traits.hpp"

include/foonathan/memory/iteration_allocator.hpp

@@ -5,6 +5,9 @@
 #ifndef FOONATHAN_MEMORY_ITERATION_ALLOCATOR_HPP_INCLUDED
 #define FOONATHAN_MEMORY_ITERATION_ALLOCATOR_HPP_INCLUDED
 
+/// \file
+/// Class template \ref foonathan::memory::iteration_allocator.
+
 #include "detail/debug_helpers.hpp"
 #include "detail/memory_stack.hpp"
 #include "default_allocator.hpp"
@@ -93,7 +96,7 @@ namespace foonathan
             /// \effects Goes to the next internal stack.
             /// This will clear the stack whose \ref max_iterations() lifetime has reached,
             /// and use it for all allocations in this iteration.
-            /// \notes This function should be called at the end of the loop.
+            /// \note This function should be called at the end of the loop.
             void next_iteration() FOONATHAN_NOEXCEPT
             {
                 cur_ = (cur_ + 1) % N;

include/foonathan/memory/joint_allocator.hpp

@@ -5,6 +5,9 @@
 #ifndef FOONATHAN_MEMORY_JOINT_ALLOCATOR_HPP_INCLUDED
 #define FOONATHAN_MEMORY_JOINT_ALLOCATOR_HPP_INCLUDED
 
+/// \file
+/// Class template \ref foonathan::memory::joint_ptr, \ref foonathan::memory::joint_allocator and related.
+
 #include <initializer_list>
 #include <new>
 
@@ -135,7 +138,7 @@ namespace foonathan
         protected:
             /// \effects Creates the base class,
             /// the tag type cannot be created by the user.
-            /// \notes This ensures that you cannot create joint types yourself.
+            /// \note This ensures that you cannot create joint types yourself.
             joint_type(joint j) FOONATHAN_NOEXCEPT;
 
             joint_type(const joint_type&) = delete;
@@ -244,7 +247,7 @@ namespace foonathan
             /// @{
             /// \effects Reserves memory for the object and the additional size,
             /// and creates the object by forwarding the arguments to its constructor.
-            /// The \cocnept{concept_rawallocator,RawAllocator} will be used for the allocation.
+            /// The \concept{concept_rawallocator,RawAllocator} will be used for the allocation.
             template <typename... Args>
             joint_ptr(allocator_type& alloc, joint_size additional_size, Args&&... args)
             : joint_ptr(alloc)
@@ -537,7 +540,7 @@ namespace foonathan
             }
 
             /// \effects Deallocates the node, if possible.
-            /// \notes It is only possible if it was the last allocation.
+            /// \note It is only possible if it was the last allocation.
             void deallocate_node(void* ptr, std::size_t size, std::size_t) FOONATHAN_NOEXCEPT
             {
                 FOONATHAN_MEMORY_ASSERT(stack_);
@@ -585,7 +588,7 @@ namespace foonathan
         /// Specialization of \ref is_thread_safe_allocator to mark \ref joint_allocator as thread safe.
         /// This is an optimization to get rid of the mutex in \ref allocator_reference,
         /// as joint allocator must not be shared between threads.
-        /// \notes The allocator is *not* thread safe, it just must not be shared.
+        /// \note The allocator is *not* thread safe, it just must not be shared.
         template <>
         struct is_thread_safe_allocator<joint_allocator> : std::true_type
         {
@@ -600,7 +603,7 @@ namespace foonathan
         /// A joint allocator does not propagate on assignment
         /// and it is not allowed to use the regular copy/move constructor of allocator aware containers,
         /// instead it needs the copy/move constructor with allocator.
-        /// \notes This is required because the container constructor will end up copying/moving the allocator.
+        /// \note This is required because the container constructor will end up copying/moving the allocator.
         /// But this is not allowed as you need the allocator with the correct joined memory.
         /// Copying can be customized (i.e. forbidden), but sadly not move, so keep that in mind.
         /// \ingroup memory allocator

include/foonathan/memory/memory_pool.hpp

@@ -156,7 +156,7 @@ namespace foonathan
 
             /// \effects Deallocates a single \concept{concept_node,node} but it does not be a result of a previous call to \ref allocate_node().
             /// \returns `true` if the node could be deallocated, `false` otherwise.
-            /// \notes Some free list implementations can deallocate any memory,
+            /// \note Some free list implementations can deallocate any memory,
             /// doesn't matter where it is coming from.
             bool try_deallocate_node(void* ptr) FOONATHAN_NOEXCEPT
             {
@@ -177,7 +177,7 @@ namespace foonathan
 
             /// \effects Deallocates an \concept{concept_array,array} but it does not be a result of a previous call to \ref allocate_array().
             /// \returns `true` if the node could be deallocated, `false` otherwise.
-            /// \notes Some free list implementations can deallocate any memory,
+            /// \note Some free list implementations can deallocate any memory,
             /// doesn't matter where it is coming from.
             bool try_deallocate_array(void* ptr, std::size_t n) FOONATHAN_NOEXCEPT
             {

include/foonathan/memory/memory_stack.hpp

@@ -338,7 +338,7 @@ namespace foonathan
             }
 
             /// \returns Whether or not the unwinder will actually unwind.
-            /// \notes It will not unwind if it is in the moved-from state.
+            /// \note It will not unwind if it is in the moved-from state.
             bool will_unwind() const FOONATHAN_NOEXCEPT
             {
                 return stack_ != nullptr;

include/foonathan/memory/segregator.hpp

@@ -5,6 +5,9 @@
 #ifndef FOONATHAN_MEMORY_SEGREGATOR_HPP_INCLUDED
 #define FOONATHAN_MEMORY_SEGREGATOR_HPP_INCLUDED
 
+/// \file
+/// Class template \ref foonathan::memory::segregator and related classes.
+
 #include "detail/ebo_storage.hpp"
 #include "detail/utility.hpp"
 #include "allocator_traits.hpp"
@@ -33,15 +36,15 @@ namespace foonathan
 
             /// \returns `true` if `size` is less then or equal to the maximum size,
             /// `false` otherwise.
-            /// \notes A return value of `true` means that the allocator will be used for the allocation.
+            /// \note A return value of `true` means that the allocator will be used for the allocation.
             bool use_allocate_node(std::size_t size, std::size_t) FOONATHAN_NOEXCEPT
             {
                 return size <= max_size_;
             }
 
             /// \returns `true` if `count * size` is less then or equal to the maximum size,
             /// `false` otherwise.
-            /// \notes A return value of `true` means that the allocator will be used for the allocation.
+            /// \note A return value of `true` means that the allocator will be used for the allocation.
             bool use_allocate_array(std::size_t count, std::size_t size,
                                     std::size_t) FOONATHAN_NOEXCEPT
             {
@@ -115,7 +118,7 @@ namespace foonathan
             }
         };
 
-        /// A \concept{concept_rawallocator,RawAllocator} that either uses the \concept{concept_segregatable,Segregatable| or the other `RawAllocator`.
+        /// A \concept{concept_rawallocator,RawAllocator} that either uses the \concept{concept_segregatable,Segregatable} or the other `RawAllocator`.
         /// It is a faster alternative to \ref fallback_allocator that doesn't require a composable allocator
         /// and decides about the allocator to use purely with the `Segregatable` based on size and alignment.
         /// \ingroup memory adapter
@@ -183,7 +186,7 @@ namespace foonathan
 
             /// @{
             /// \returns The maximum value of the fallback.
-            /// \notes It assumes that the fallback will be used for larger allocations,
+            /// \note It assumes that the fallback will be used for larger allocations,
             /// and the `Segregatable` for smaller ones.
             std::size_t max_node_size() const
             {
@@ -367,7 +370,7 @@ namespace foonathan
         /// Then the result is a simple \ref binary_segregator with those arguments.
         /// If you pass more than one, the last one must be a `RawAllocator` all others `Segregatable`,
         /// the result is `binary_segregator<Head, segregator<Tail...>>`.
-        /// \notes It will result in an allocator that tries each `Segregatable` in the order specified
+        /// \note It will result in an allocator that tries each `Segregatable` in the order specified
         /// using the last parameter as final fallback.
         /// \ingroup memory adapter
         template <class... Allocators>

include/foonathan/memory/temporary_allocator.hpp

@@ -169,14 +169,14 @@ namespace foonathan
 
         /// Manually takes care of the lifetime of the per-thread \ref temporary_stack.
         /// The constructor will create it, if not already done, and the destructor will destroy it, if not already done.
-        /// \notes If there are multiple objects in a thread,
+        /// \note If there are multiple objects in a thread,
         /// this will lead to unnecessary construction and destruction of the stack.
         /// It is thus adviced to create one object on the top-level function of the thread, e.g. in `main()`.
-        /// \notes If `FOONATHAN_MEMORY_TEMPORARY_STACK_MODE == 2`, it is not necessary to use this class,
+        /// \note If `FOONATHAN_MEMORY_TEMPORARY_STACK_MODE == 2`, it is not necessary to use this class,
         /// the nifty counter will clean everything upon program termination.
         /// But it can still be used as an optimization if you have a thread that is terminated long before program exit.
         /// The automatic clean up will only occur much later.
-        /// \notes If `FOONATHAN_MEMORY_TEMPORARY_STACK_MODE == 0`, the use of this class has no effect,
+        /// \note If `FOONATHAN_MEMORY_TEMPORARY_STACK_MODE == 0`, the use of this class has no effect,
         /// because the per-thread stack is disabled.
         /// \relatesalso temporary_stack
         class temporary_stack_initializer
@@ -186,19 +186,21 @@ namespace foonathan
 
             static const struct defer_create_t
             {
-                defer_create_t() FOONATHAN_NOEXCEPT {}
+                defer_create_t() FOONATHAN_NOEXCEPT
+                {
+                }
             } defer_create;
 
             /// \effects Does not create the per-thread stack.
             /// It will be created by the first call to \ref get_temporary_stack() in the current thread.
-            /// \notes If `FOONATHAN_MEMORY_TEMPORARY_STACK_MODE == 0`, this function has no effect.
+            /// \note If `FOONATHAN_MEMORY_TEMPORARY_STACK_MODE == 0`, this function has no effect.
             temporary_stack_initializer(defer_create_t) FOONATHAN_NOEXCEPT
             {
             }
 
             /// \effects Creates the per-thread stack with the given default size if it wasn't already created.
             /// \requires `initial_size` must not be `0` if `FOONATHAN_MEMORY_TEMPORARY_STACK_MODE != 0`.
-            /// \notes If `FOONATHAN_MEMORY_TEMPORARY_STACK_MODE == 0`, this function will issue a warning in debug mode.
+            /// \note If `FOONATHAN_MEMORY_TEMPORARY_STACK_MODE == 0`, this function will issue a warning in debug mode.
             /// This can be disabled by passing `0` as the initial size.
             temporary_stack_initializer(std::size_t initial_size = default_stack_size);
 
@@ -213,7 +215,7 @@ namespace foonathan
         /// if it wasn't already created.
         /// \returns The per-thread \ref temporary_stack.
         /// \requires There must be a per-thread temporary stack (\ref FOONATHAN_MEMORY_TEMPORARY_STACK_MODE must not be equal to `0`).
-        /// \notes If \ref FOONATHAN_MEMORY_TEMPORARY_STACK_MODE is equal to `1`,
+        /// \note If \ref FOONATHAN_MEMORY_TEMPORARY_STACK_MODE is equal to `1`,
         /// this function can create the temporary stack.
         /// But if there is no \ref temporary_stack_initializer, it won't be destroyed.
         /// \relatesalso temporary_stack
@@ -248,15 +250,15 @@ namespace foonathan
             void* allocate(std::size_t size, std::size_t alignment);
 
             /// \returns Whether or not the allocator object is active.
-            /// \notes The active allocator object is the last object created for one stack.
+            /// \note The active allocator object is the last object created for one stack.
             /// Moving changes the active allocator.
             bool is_active() const FOONATHAN_NOEXCEPT;
 
             /// \effects Instructs it to release unnecessary memory after automatic unwinding occurs.
             /// This will effectively forward to \ref memory_stack::shrink_to_fit() of the internal stack.
-            /// \notes Like the use of the \ref temporary_stack_initializer this can be used as an optimization,
+            /// \note Like the use of the \ref temporary_stack_initializer this can be used as an optimization,
             /// to tell when the thread's \ref temporary_stack isn't needed anymore and can be destroyed.
-            /// \notes It doesn't call shrink to fit immediately, only in the destructor!
+            /// \note It doesn't call shrink to fit immediately, only in the destructor!
             void shrink_to_fit() FOONATHAN_NOEXCEPT;
 
             /// \returns The internal stack the temporary allocator is using.