Ticket #6952: 0001-Fix-mixed-comment-style-that-might-be-confusing-doc-.patch

boost/interprocess/detail/managed_memory_impl.hpp

@@ -60 +60 @@
 //!achieve this, this class uses the reserved space provided by the allocation
 //!algorithm to place a named_allocator_algo, who takes care of name mappings.
 //!The class can be customized with the char type used for object names
-//!and the memory allocation algorithm to be used.*/
+//!and the memory allocation algorithm to be used.
 template <  class CharType
          ,  class MemoryAlgorithm
          ,  template<class IndexConfig> class IndexType
@@ -265 +265 @@
    }
 
    //!Transforms previously obtained offset into an absolute address in the
-   //!process space of the current process. Never throws.*/
+   //!process space of the current process. Never throws.
    void *    get_address_from_handle (handle_t offset) const
    {  return reinterpret_cast<char*>(this->get_address()) + offset; }
 
@@ -483 +483 @@
    //!-> If T's constructor throws, the function throws that exception.
    //!
    //!Memory is freed automatically if T's constructor throws and
-   //!destructors of created objects are called before freeing the memory.*/
+   //!destructors of created objects are called before freeing the memory.
    template <class T>
    typename segment_manager::template construct_iter_proxy<T>::type
       construct_it(char_ptr_holder_t name, std::nothrow_t nothrow)
@@ -506 +506 @@
    //!-> If T's constructor throws, the function throws that exception.
    //!
    //!Memory is freed automatically if T's constructor throws and
-   //!destructors of created objects are called before freeing the memory.*/
+   //!destructors of created objects are called before freeing the memory.
    template <class T>
    typename segment_manager::template construct_iter_proxy<T>::type
       find_or_construct_it(char_ptr_holder_t name, std::nothrow_t nothrow)

boost/interprocess/indexes/iset_index.hpp

@@ -56 +56 @@
 
 //!Index type based in boost::intrusive::set.
 //!Just derives from boost::intrusive::set
-//!and defines the interface needed by managed memory segments*/
+//!and defines the interface needed by managed memory segments
 template <class MapConfig>
 class iset_index
    //Derive class from map specialization

boost/interprocess/ipc/message_queue.hpp

@@ -99 +99 @@
 
    //!Sends a message stored in buffer "buffer" with size "buffer_size" in the
    //!message queue with priority "priority". If the message queue is full
-   //!the sender is blocked. Throws interprocess_error on error.*/
+   //!the sender is blocked. Throws interprocess_error on error.
    void send (const void *buffer,     size_type buffer_size,
               unsigned int priority);
 
@@ -269 +269 @@
    //!Constructor. This object must be constructed in the beginning of the
    //!shared memory of the size returned by the function "get_mem_size".
    //!This constructor initializes the needed resources and creates
-   //!the internal structures like the priority index. This can throw.*/
+   //!the internal structures like the priority index. This can throw.
    mq_hdr_t(size_type max_num_msg, size_type max_msg_size)
       : m_max_num_msg(max_num_msg),
          m_max_msg_size(max_msg_size),

boost/interprocess/managed_external_buffer.hpp

@@ -35 +35 @@
 
 //!A basic user memory named object creation class. Inherits all
 //!basic functionality from
-//!basic_managed_memory_impl<CharType, AllocationAlgorithm, IndexType>*/
+//!basic_managed_memory_impl<CharType, AllocationAlgorithm, IndexType>
 template
       <
          class CharType,

boost/interprocess/managed_heap_memory.hpp

@@ -36 +36 @@
 
 //!A basic heap memory named object creation class. Initializes the
 //!heap memory segment. Inherits all basic functionality from
-//!basic_managed_memory_impl<CharType, AllocationAlgorithm, IndexType>*/
+//!basic_managed_memory_impl<CharType, AllocationAlgorithm, IndexType>
 template
       <
          class CharType,

boost/interprocess/managed_shared_memory.hpp

@@ -34 +34 @@
 
 //!A basic shared memory named object creation class. Initializes the
 //!shared memory segment. Inherits all basic functionality from
-//!basic_managed_memory_impl<CharType, AllocationAlgorithm, IndexType>*/
+//!basic_managed_memory_impl<CharType, AllocationAlgorithm, IndexType>
 template
       <
          class CharType,

boost/interprocess/managed_xsi_shared_memory.hpp

@@ -38 +38 @@
 
 //!A basic X/Open System Interface (XSI) shared memory named object creation class. Initializes the
 //!shared memory segment. Inherits all basic functionality from
-//!basic_managed_memory_impl<CharType, AllocationAlgorithm, IndexType>*/
+//!basic_managed_memory_impl<CharType, AllocationAlgorithm, IndexType>
 template
       <
          class CharType,

boost/interprocess/mem_algo/simple_seq_fit.hpp

@@ -43 +43 @@
 
    //!Constructor. "size" is the total size of the managed memory segment,
    //!"extra_hdr_bytes" indicates the extra bytes beginning in the sizeof(simple_seq_fit)
-   //!offset that the allocator should not use at all.*/
+   //!offset that the allocator should not use at all.
    simple_seq_fit           (size_type size, size_type extra_hdr_bytes)
       : base_t(size, extra_hdr_bytes){}
 };

boost/interprocess/segment_manager.hpp

@@ -499 +499 @@
 
    //!Calls object function blocking recursive interprocess_mutex and guarantees that
    //!no new named_alloc or destroy will be executed by any process while
-   //!executing the object function call*/
+   //!executing the object function call
    template <class Func>
    void atomic_func(Func &f)
    {  scoped_lock<rmutex> guard(m_header);  f();  }

boost/interprocess/shared_memory_object.hpp

@@ -61 +61 @@
    shared_memory_object();
 
    //!Creates a shared memory object with name "name" and mode "mode", with the access mode "mode"
-   //!If the file previously exists, throws an error.*/
+   //!If the file previously exists, throws an error.
    shared_memory_object(create_only_t, const char *name, mode_t mode, const permissions &perm = permissions())
    {  this->priv_open_or_create(ipcdetail::DoCreate, name, mode, perm);  }
 

boost/interprocess/sync/interprocess_semaphore.hpp

@@ -56 +56 @@
    /// @endcond
    public:
    //!Creates a interprocess_semaphore with the given initial count.
-   //!interprocess_exception if there is an error.*/
+   //!interprocess_exception if there is an error.
    interprocess_semaphore(unsigned int initialCount);
 
    //!Destroys the interprocess_semaphore.

boost/interprocess/sync/interprocess_upgradable_mutex.hpp

@@ -176 +176 @@
    //!   fail if there are threads with sharable ownership or timeout reaches, but it
    //!   will maintain upgradable ownership.
    //!Returns: If acquires exclusive ownership, returns true. Otherwise returns false.
-   //!Throws: An exception derived from interprocess_exception on error. */
+   //!Throws: An exception derived from interprocess_exception on error. 
    bool timed_unlock_upgradable_and_lock(const boost::posix_time::ptime &abs_time);
 
    //!Precondition: The thread must have sharable ownership of the mutex.

boost/interprocess/sync/named_condition.hpp

@@ -77 +77 @@
    ~named_condition();
 
    //!If there is a thread waiting on *this, change that
-   //!thread's state to ready. Otherwise there is no effect.*/
+   //!thread's state to ready. Otherwise there is no effect.
    void notify_one();
 
    //!Change the state of all threads waiting on *this to ready.

boost/interprocess/sync/scoped_lock.hpp

@@ -245 +245 @@
    }
 
    //!Effects: if (owns()) mp_mutex->unlock().
-   //!Notes: The destructor behavior ensures that the mutex lock is not leaked.*/
+   //!Notes: The destructor behavior ensures that the mutex lock is not leaked.
    ~scoped_lock()
    {
       try{  if(m_locked && mp_mutex)   mp_mutex->unlock();  }
@@ -286 +286 @@
    //!Notes: The scoped_lock changes from a state of not owning the mutex, to
    //!   owning the mutex, but only if blocking was not required. If the
    //!   mutex_type does not support try_lock(), this function will fail at
-   //!   compile time if instantiated, but otherwise have no effect.*/
+   //!   compile time if instantiated, but otherwise have no effect.
    bool try_lock()
    {
       if(!mp_mutex || m_locked)
@@ -301 +301 @@
    //!Notes: The scoped_lock changes from a state of not owning the mutex, to
    //!   owning the mutex, but only if it can obtain ownership by the specified
    //!   time. If the mutex_type does not support timed_lock (), this function
-   //!   will fail at compile time if instantiated, but otherwise have no effect.*/
+   //!   will fail at compile time if instantiated, but otherwise have no effect.
    bool timed_lock(const boost::posix_time::ptime& abs_time)
    {
       if(!mp_mutex || m_locked)
@@ -314 +314 @@
    //!   exception. Calls unlock() on the referenced mutex.
    //!Postconditions: owns() == false.
    //!Notes: The scoped_lock changes from a state of owning the mutex, to not
-   //!   owning the mutex.*/
+   //!   owning the mutex.
    void unlock()
    {
       if(!mp_mutex || !m_locked)

boost/interprocess/sync/sharable_lock.hpp

@@ -45 +45 @@
 //!the Mutex does not supply, no harm is done. Mutex ownership can be shared among
 //!sharable_locks, and a single upgradable_lock. sharable_lock does not support
 //!copy semantics. But sharable_lock supports ownership transfer from an sharable_lock,
-//!upgradable_lock and scoped_lock via transfer_lock syntax.*/
+//!upgradable_lock and scoped_lock via transfer_lock syntax.
 template <class SharableMutex>
 class sharable_lock
 {
@@ -136 +136 @@
    //!Notes: If upgr is locked, this constructor will lock this sharable_lock while
    //!   unlocking upgr. Only a moved sharable_lock's will match this
    //!   signature. An non-moved upgradable_lock can be moved with the expression:
-   //!   "boost::move(lock);".*/
+   //!   "boost::move(lock);".
    template<class T>
    sharable_lock(BOOST_RV_REF(upgradable_lock<T>) upgr
       , typename ipcdetail::enable_if< ipcdetail::is_same<T, SharableMutex> >::type * = 0)

boost/interprocess/sync/shm/named_condition.hpp

@@ -83 +83 @@
    ~shm_named_condition();
 
    //!If there is a thread waiting on *this, change that
-   //!thread's state to ready. Otherwise there is no effect.*/
+   //!thread's state to ready. Otherwise there is no effect.
    void notify_one();
 
    //!Change the state of all threads waiting on *this to ready.

boost/interprocess/sync/windows/named_condition.hpp

@@ -49 +49 @@
    ~windows_named_condition();
 
    //!If there is a thread waiting on *this, change that
-   //!thread's state to ready. Otherwise there is no effect.*/
+   //!thread's state to ready. Otherwise there is no effect.
    void notify_one();
 
    //!Change the state of all threads waiting on *this to ready.

libs/container/test/heap_allocator_v1.hpp

@@ -41 +41 @@
 //!An STL compatible heap_allocator_v1 that uses a segment manager as
 //!memory source. The internal pointer type will of the same type (raw, smart) as
 //!"typename SegmentManager::void_pointer" type. This allows
-//!placing the heap_allocator_v1 in shared memory, memory mapped-files, etc...*/
+//!placing the heap_allocator_v1 in shared memory, memory mapped-files, etc...
 template<class T, class SegmentManager>
 class heap_allocator_v1
 {

libs/interprocess/doc/interprocess.qbk

@@ -3088 +3088 @@
    //!and offset_ptr as internal pointers) as memory allocation algorithm
    //!and the default index type as the index.
    //!This class allows the shared memory to be mapped in different base
-   //!in different processes*/
+   //!in different processes
    typedef basic_managed_shared_memory
       <char
       ,/*Default memory algorithm defining void * as void_pointer*/

libs/interprocess/test/allocator_v1.hpp

@@ -41 +41 @@
 //!An STL compatible allocator_v1 that uses a segment manager as
 //!memory source. The internal pointer type will of the same type (raw, smart) as
 //!"typename SegmentManager::void_pointer" type. This allows
-//!placing the allocator_v1 in shared memory, memory mapped-files, etc...*/
+//!placing the allocator_v1 in shared memory, memory mapped-files, etc...
 template<class T, class SegmentManager>
 class allocator_v1
 {

libs/interprocess/test/heap_allocator_v1.hpp

@@ -41 +41 @@
 //!An STL compatible heap_allocator_v1 that uses a segment manager as
 //!memory source. The internal pointer type will of the same type (raw, smart) as
 //!"typename SegmentManager::void_pointer" type. This allows
-//!placing the heap_allocator_v1 in shared memory, memory mapped-files, etc...*/
+//!placing the heap_allocator_v1 in shared memory, memory mapped-files, etc...
 template<class T, class SegmentManager>
 class heap_allocator_v1
 {