Style fixes to Messenger, no functional change intended

headers/os/app/Messenger.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2001-2007, Haiku, Inc. All Rights Reserved.
+ * Copyright 2001-2011 Haiku, Inc. All rights reserved.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
@@ -13,18 +13,20 @@
 #include <ByteOrder.h>
 #include <Message.h>
 
+
 class BHandler;
 class BLooper;
 
-
 class BMessenger {
 public:
 									BMessenger();
-	BMessenger(const char *signature, team_id team = -1,
+									BMessenger(const char* signature,
+										team_id team = -1,
 										status_t* result = NULL);
-	BMessenger(const BHandler *handler, const BLooper *looper = NULL,
+									BMessenger(const BHandler* handler,
+										const BLooper* looper = NULL,
 										status_t* result = NULL);
-	BMessenger(const BMessenger &from);
+									BMessenger(const BMessenger& other);
 									~BMessenger();
 
 	// Target
@@ -32,26 +34,38 @@ public:
 			bool					IsTargetLocal() const;
 			BHandler*				Target(BLooper **looper) const;
 			bool					LockTarget() const;
-	status_t LockTargetWithTimeout(bigtime_t timeout) const;
+			status_t				LockTargetWithTimeout(
+										bigtime_t timeout) const;
 
 	// Message sending
 
-	status_t SendMessage(uint32 command, BHandler *replyTo = NULL) const;
+			status_t				SendMessage(uint32 command,
-	status_t SendMessage(BMessage *message, BHandler *replyTo = NULL,
+										BHandler* replyTo = NULL) const;
-						 bigtime_t timeout = B_INFINITE_TIMEOUT) const;
+			status_t				SendMessage(BMessage* message,
-	status_t SendMessage(BMessage *message, BMessenger replyTo,
+										BHandler* replyTo = NULL,
-						 bigtime_t timeout = B_INFINITE_TIMEOUT) const;
+										bigtime_t timeout
-	status_t SendMessage(uint32 command, BMessage *reply) const;
+											= B_INFINITE_TIMEOUT) const;
-	status_t SendMessage(BMessage *message, BMessage *reply,
+			status_t				SendMessage(BMessage* message,
-						 bigtime_t deliveryTimeout = B_INFINITE_TIMEOUT,
+										BMessenger replyTo,
-						 bigtime_t replyTimeout = B_INFINITE_TIMEOUT) const;
+										bigtime_t timeout
+											= B_INFINITE_TIMEOUT) const;
+			status_t				SendMessage(uint32 command,
+										BMessage* reply) const;
+			status_t				SendMessage(BMessage* message,
+										BMessage* reply,
+										bigtime_t deliveryTimeout
+											= B_INFINITE_TIMEOUT,
+										bigtime_t replyTimeout
+											= B_INFINITE_TIMEOUT) const;
 	
 	// Operators and misc
 
-	status_t SetTo(const char *signature, team_id team = -1);
+			status_t				SetTo(const char* signature,
-	status_t SetTo(const BHandler *handler, const BLooper *looper = NULL);
+										team_id team = -1);
+			status_t				SetTo(const BHandler* handler,
+										const BLooper* looper = NULL);
 
-	BMessenger &operator=(const BMessenger &from);
+			BMessenger&				operator=(const BMessenger& other);
 			bool					operator==(const BMessenger& other) const;
 
 			bool					IsValid() const;
@@ -66,9 +80,12 @@ public:
 private:
 	friend class Private;
 
-	void _SetTo(team_id team, port_id port, int32 token);
+			void					_SetTo(team_id team, port_id port,
-	void _InitData(const char *signature, team_id team, status_t *result);
+										int32 token);
-	void _InitData(const BHandler *handler, const BLooper *looper,
+			void					_InitData(const char* signature,
+										team_id team, status_t* result);
+			void					_InitData(const BHandler* handler,
+										const BLooper *looper,
 										status_t* result);
 
 private:
@@ -82,4 +99,5 @@ private:
 bool operator<(const BMessenger& a, const BMessenger& b);
 bool operator!=(const BMessenger& a, const BMessenger& b);
 
+
 #endif	// _MESSENGER_H

src/kits/app/Messenger.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright 2001-2011, Haiku.
+ * Copyright 2001-2011 Haiku, Inc. All rights reserved.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
@@ -42,8 +42,6 @@ enum {
 };
 
 
-/*!	\brief Creates an unitialized BMessenger.
-*/
 BMessenger::BMessenger()
 	:
 	fPort(-1),
@@ -53,20 +51,6 @@ BMessenger::BMessenger()
 }
 
 
-/*!	\brief Creates a BMessenger and initializes it to target the already
-	running application identified by its signature and/or team ID.
-
-	When only a signature is given, and multiple instances of the application
-	are running it is undeterminate which one is chosen as the target. In case
-	only a team ID is passed, the target application is identified uniquely.
-	If both are supplied, the application identified by the team ID must have
-	a matching signature, otherwise the initilization fails.
-
-	\param signature The target application's signature. May be \c NULL.
-	\param team The target application's team ID. May be < 0.
-	\param result An optional pointer to a pre-allocated status_t into which
-		   the result of the initialization is written.
-*/
 BMessenger::BMessenger(const char* signature, team_id team, status_t* result)
 	:
 	fPort(-1),
@@ -77,20 +61,6 @@ BMessenger::BMessenger(const char *signature, team_id team, status_t *result)
 }
 
 
-/*!	\brief Creates a BMessenger and initializes it to target the local
-	BHandler and/or BLooper.
-
-	When a \c NULL handler is supplied, the preferred handler in the given
-	looper is targeted. If no looper is supplied the looper the given handler
-	belongs to is used -- that means in particular, that the handler must
-	already belong to a looper. If both are supplied the handler must actually
-	belong to looper.
-
-	\param handler The target handler. May be \c NULL.
-	\param looper The target looper. May be \c NULL.
-	\param result An optional pointer to a pre-allocated status_t into which
-		   the result of the initialization is written.
-*/
 BMessenger::BMessenger(const BHandler* handler, const BLooper* looper,
 	status_t* _result)
 	:
@@ -102,22 +72,15 @@ BMessenger::BMessenger(const BHandler* handler, const BLooper* looper,
 }
 
 
-/*!	\brief Creates a BMessenger and initializes it to have the same target
+BMessenger::BMessenger(const BMessenger& other)
-	as the supplied messemger.
-
-	\param from The messenger to be copied.
-*/
-BMessenger::BMessenger(const BMessenger& from)
 	:
-	fPort(from.fPort),
+	fPort(other.fPort),
-	fHandlerToken(from.fHandlerToken),
+	fHandlerToken(other.fHandlerToken),
-	fTeam(from.fTeam)
+	fTeam(other.fTeam)
 {
 }
 
 
-/*!	\brief Frees all resources associated with this object.
-*/
 BMessenger::~BMessenger()
 {
 }
@@ -126,12 +89,6 @@ BMessenger::~BMessenger()
 //	#pragma mark - Target
 
 
-/*!	\brief Returns whether or not the messenger's target lives within the team
-	of the caller.
-
-	\return \c true, if the object is properly initialized and its target
-			lives within the caller's team, \c false otherwise.
-*/
 bool
 BMessenger::IsTargetLocal() const
 {
@@ -139,19 +96,6 @@ BMessenger::IsTargetLocal() const
 }
 
 
-/*!	\brief Returns the handler and looper targeted by the messenger, if the
-	target is local.
-
-	The handler is returned directly, the looper by reference. If both are
-	\c NULL, the object is either not properly initialized, the target
-	objects have been deleted or the target is remote. If only the returned
-	handler is \c NULL, either the looper's preferred handler is targeted or
-	the handler has been deleted.
-
-	\param looper A pointer to a pre-allocated BLooper pointer into which
-		   the pointer to the targeted looper is written.
-	\return The BHandler targeted by the messenger.
-*/
 BHandler*
 BMessenger::Target(BLooper** _looper) const
 {
@@ -170,17 +114,6 @@ BMessenger::Target(BLooper** _looper) const
 }
 
 
-/*!	\brief Locks the BLooper targeted by the messenger, if the target is local.
-
-	This method is a shorthand for retrieving the targeted looper via
-	Target() and calling BLooper::Lock() on the looper afterwards.
-
-	\see BLooper::Lock() for details.
-
-	\return \c true, if the looper could be locked successfully, \c false, if
-			the messenger is not properly initialized, the target is remote,
-			or the targeted looper is invalid.
-*/
 bool
 BMessenger::LockTarget() const
 {
@@ -198,19 +131,6 @@ BMessenger::LockTarget() const
 }
 
 
-/*!	\brief Locks the BLooper targeted by the messenger, if the target is local.
-
-	This method is a shorthand for retrieving the targeted looper via
-	Target() and calling BLooper::LockWithTimeout() on the looper afterwards.
-
-	\see BLooper::LockWithTimeout() for details.
-
-	\return
-	- \c B_OK, if the looper could be locked successfully,
-	- \c B_BAD_VALUE, if the messenger is not properly initialized,
-	  the target is remote, or the targeted looper is invalid,
-	- other error codes returned by BLooper::LockWithTimeout().
-*/
 status_t
 BMessenger::LockTargetWithTimeout(bigtime_t timeout) const
 {
@@ -219,36 +139,20 @@ BMessenger::LockTargetWithTimeout(bigtime_t timeout) const
 	if (looper == NULL)
 		return B_BAD_VALUE;
 
-	status_t error = looper->LockWithTimeout(timeout);
+	status_t result = looper->LockWithTimeout(timeout);
 
-	if (error == B_OK && looper->fMsgPort != fPort) {
+	if (result == B_OK && looper->fMsgPort != fPort) {
 		looper->Unlock();
 		return B_BAD_PORT_ID;
 	}
 
-	return error;
+	return result;
 }
 
 
 //	#pragma mark - Message sending
 
 
-/*! \brief Delivers a BMessage synchronously to the messenger's target,
-		   without waiting for a reply.
-
-	If the target's message port is full, the method waits indefinitely, until
-	space becomes available in the port. After delivery the method returns
-	immediately. It does not wait until the target processes the message or
-	even sends a reply.
-
-	\param command The what field of the message to deliver.
-	\param replyTo The handler to which a reply to the message shall be sent.
-		   May be \c NULL.
-	\return
-	- \c B_OK: Everything went fine.
-	- \c B_BAD_PORT_ID: The messenger is not properly initialized or its
-	  target doesn't exist anymore.
-*/
 status_t
 BMessenger::SendMessage(uint32 command, BHandler* replyTo) const
 {
@@ -257,73 +161,29 @@ BMessenger::SendMessage(uint32 command, BHandler *replyTo) const
 }
 
 
-/*! \brief Delivers a BMessage synchronously to the messenger's target,
-		   without waiting for a reply.
-
-	A copy of the supplied message is sent and the caller retains ownership
-	of \a message.
-
-	If the target's message port is full, the method waits until space becomes
-	available in the port or the specified timeout occurs (whichever happens
-	first). After delivery the method returns immediately. It does not wait
-	until the target processes the message or even sends a reply.
-
-	\param message The message to be sent.
-	\param replyTo The handler to which a reply to the message shall be sent.
-		   May be \c NULL.
-	\param timeout A timeout for the delivery of the message.
-	\return
-	- \c B_OK: Everything went fine.
-	- \c B_BAD_PORT_ID: The messenger is not properly initialized or its
-	  target doesn't exist anymore.
-	- \c B_WOULD_BLOCK: A delivery timeout of 0 was supplied and the target
-	  port was full when trying to deliver the message.
-	- \c B_TIMED_OUT: The timeout expired while trying to deliver the
-	  message.
-*/
 status_t
 BMessenger::SendMessage(BMessage* message, BHandler* replyTo,
 	bigtime_t timeout) const
 {
 	DBG(OUT("BMessenger::SendMessage2(%.4s)\n", (char*)&message->what));
-	status_t error = (message ? B_OK : B_BAD_VALUE);
+
-	if (error == B_OK) {
+	status_t result = message != NULL ? B_OK : B_BAD_VALUE;
+	if (result == B_OK) {
 		BMessenger replyMessenger(replyTo);
-		error = SendMessage(message, replyMessenger, timeout);
+		result = SendMessage(message, replyMessenger, timeout);
 	}
-	DBG(OUT("BMessenger::SendMessage2() done: %lx\n", error));
+
-	return error;
+	DBG(OUT("BMessenger::SendMessage2() done: %lx\n", result));
+
+	return result;
 }
 
 
-/*! \brief Delivers a BMessage synchronously to the messenger's target,
-		   without waiting for a reply.
-
-	A copy of the supplied message is sent and the caller retains ownership
-	of \a message.
-
-	If the target's message port is full, the method waits until space becomes
-	available in the port or the specified timeout occurs (whichever happens
-	first). After delivery the method returns immediately. It does not wait
-	until the target processes the message or even sends a reply.
-
-	\param message The message to be sent.
-	\param replyTo A messenger specifying the target for a reply to \a message.
-	\param timeout A timeout for the delivery of the message.
-	\return
-	- \c B_OK: Everything went fine.
-	- \c B_BAD_PORT_ID: The messenger is not properly initialized or its
-	  target doesn't exist anymore.
-	- \c B_WOULD_BLOCK: A delivery timeout of 0 was supplied and the target
-	  port was full when trying to deliver the message.
-	- \c B_TIMED_OUT: The timeout expired while trying to deliver the
-	  message.
-*/
 status_t
 BMessenger::SendMessage(BMessage* message, BMessenger replyTo,
 	bigtime_t timeout) const
 {
-	if (!message)
+	if (message == NULL)
 		return B_BAD_VALUE;
 
 	return BMessage::Private(message).SendMessage(fPort, fTeam, fHandlerToken,
@@ -331,55 +191,15 @@ BMessenger::SendMessage(BMessage *message, BMessenger replyTo,
 }
 
 
-/*! \brief Delivers a BMessage synchronously to the messenger's target and
-	waits for a reply.
-
-	The method does wait for a reply. The reply message is copied into
-	\a reply. If the target doesn't send a reply, the \c what field of
-	\a reply is set to \c B_NO_REPLY.
-
-	\param command The what field of the message to deliver.
-	\param reply A pointer to a pre-allocated BMessage into which the reply
-		   message will be copied.
-	\return
-	- \c B_OK: Everything went fine.
-	- \c B_BAD_PORT_ID: The messenger is not properly initialized or its
-	  target doesn't exist anymore.
-	- \c B_NO_MORE_PORTS: All reply ports are in use.
-*/
 status_t
 BMessenger::SendMessage(uint32 command, BMessage* reply) const
 {
 	BMessage message(command);
+
 	return SendMessage(&message, reply);
 }
 
 
-/*! \brief Delivers a BMessage synchronously to the messenger's target and
-	waits for a reply.
-
-	A copy of the supplied message is sent and the caller retains ownership
-	of \a message.
-
-	The method does wait for a reply. The reply message is copied into
-	\a reply. If the target doesn't send a reply or if a reply timeout occurs,
-	the \c what field of \a reply is set to \c B_NO_REPLY.
-
-	\param message The message to be sent.
-	\param reply A pointer to a pre-allocated BMessage into which the reply
-		   message will be copied.
-	\param deliveryTimeout A timeout for the delivery of the message.
-	\param replyTimeout A timeout for waiting for the reply.
-	\return
-	- \c B_OK: Everything went fine.
-	- \c B_BAD_PORT_ID: The messenger is not properly initialized or its
-	  target doesn't exist anymore.
-	- \c B_WOULD_BLOCK: A delivery timeout of 0 was supplied and the target
-	  port was full when trying to deliver the message.
-	- \c B_TIMED_OUT: The timeout expired while trying to deliver the
-	  message.
-	- \c B_NO_MORE_PORTS: All reply ports are in use.
-*/
 status_t
 BMessenger::SendMessage(BMessage* message, BMessage* reply,
 	bigtime_t deliveryTimeout, bigtime_t replyTimeout) const
@@ -387,104 +207,61 @@ BMessenger::SendMessage(BMessage *message, BMessage *reply,
 	if (message == NULL || reply == NULL)
 		return B_BAD_VALUE;
 
-	status_t error = BMessage::Private(message).SendMessage(fPort, fTeam,
+	status_t result = BMessage::Private(message).SendMessage(fPort, fTeam,
 		fHandlerToken, reply, deliveryTimeout, replyTimeout);
 
-	// Map this error for now:
+	// map this result for now
-	if (error == B_BAD_TEAM_ID)
+	if (result == B_BAD_TEAM_ID)
-		error = B_BAD_PORT_ID;
+		result = B_BAD_PORT_ID;
 
-	return error;
+	return result;
 }
 
 
 //	#pragma mark - Operators and misc
 
 
-/*!	\brief Reinitializes a BMessenger to target the already running application
-	identified by the supplied signature and/or team ID.
-
-	When only a signature is given, and multiple instances of the application
-	are running it is undeterminate which one is chosen as the target. In case
-	only a team ID is passed, the target application is identified uniquely.
-	If both are supplied, the application identified by the team ID must have
-	a matching signature, otherwise the initilization fails.
-
-	\param signature The target application's signature. May be \c NULL.
-	\param team The target application's team ID. May be < 0.
-	\return The result of the reinitialization.
-*/
 status_t
 BMessenger::SetTo(const char* signature, team_id team)
 {
 	status_t result = B_OK;
 	_InitData(signature, team, &result);
+
 	return result;
 }
 
 
-/*!	\brief Reinitializes a BMessenger to target the local BHandler and/or
-	BLooper.
-
-	When a \c NULL handler is supplied, the preferred handler in the given
-	looper is targeted. If no looper is supplied the looper the given handler
-	belongs to is used -- that means in particular, that the handler must
-	already belong to a looper. If both are supplied the handler must actually
-	belong to looper.
-
-	\param handler The target handler. May be \c NULL.
-	\param looper The target looper. May be \c NULL.
-	\return The result of the reinitialization.
-*/
 status_t
 BMessenger::SetTo(const BHandler* handler, const BLooper* looper)
 {
 	status_t result = B_OK;
 	_InitData(handler, looper, &result);
+
 	return result;
 }
 
 
-/*!	\brief Makes this BMessenger a copy of the supplied one.
-
-	\param from the messenger to be copied.
-	\return A reference to this object.
-*/
 BMessenger&
-BMessenger::operator=(const BMessenger &from)
+BMessenger::operator=(const BMessenger& other)
 {
-	if (this != &from) {
+	if (this != &other) {
-		fPort = from.fPort;
+		fPort = other.fPort;
-		fHandlerToken = from.fHandlerToken;
+		fHandlerToken = other.fHandlerToken;
-		fTeam = from.fTeam;
+		fTeam = other.fTeam;
 	}
+
 	return *this;
 }
 
 
-/*!	\brief Returns whether this and the supplied messenger have the same
-	target.
-
-	\param other The other messenger.
-	\return \c true, if the messengers have the same target or if both aren't
-			properly initialzed, \c false otherwise.
-*/
 bool
 BMessenger::operator==(const BMessenger& other) const
 {
 	// Note: The fTeam fields are not compared.
-	return fPort == other.fPort
+	return fPort == other.fPort && fHandlerToken == other.fHandlerToken;
-		&& fHandlerToken == other.fHandlerToken;
 }
 
 
-/*!	\brief Returns whether the messenger's target looper does still exist.
-
-	It is not checked whether the target handler is also still existing.
-
-	\return \c true, if the messenger's target looper does still exist,
-			\c false otherwise.
-*/
 bool
 BMessenger::IsValid() const
 {
@@ -493,10 +270,6 @@ BMessenger::IsValid() const
 }
 
 
-/*!	\brief Returns the ID of the team the messenger's target lives in.
-
-	\return The team of the messenger's target.
-*/
 team_id
 BMessenger::Team() const
 {
@@ -514,9 +287,9 @@ BMessenger::HashValue() const
 //	#pragma mark - Private or reserved
 
 
-/*!	\brief Sets the messenger's team, target looper port and handler token.
+/*!	Sets the messenger's team, target looper port and handler token.
 
-	To target the preferred handler, use B_PREFERRED_TOKEN as token.
+	To target the preferred handler, use \c B_PREFERRED_TOKEN as token.
 
 	\param team The target's team.
 	\param port The target looper port.
@@ -531,7 +304,7 @@ BMessenger::_SetTo(team_id team, port_id port, int32 token)
 }
 
 
-/*!	\brief Initializes the BMessenger object's data given the signature and/or
+/*!	Initializes the BMessenger object's data given the signature and/or
 	team ID of a target.
 
 	When only a signature is given, and multiple instances of the application
@@ -548,49 +321,51 @@ BMessenger::_SetTo(team_id team, port_id port, int32 token)
 void
 BMessenger::_InitData(const char* signature, team_id team, status_t* _result)
 {
-	status_t error = B_OK;
+	status_t result = B_OK;
+
 	// get an app_info
 	app_info info;
 	if (team < 0) {
 		// no team ID given
-		if (signature) {
+		if (signature != NULL) {
-			error = be_roster->GetAppInfo(signature, &info);
+			result = be_roster->GetAppInfo(signature, &info);
 			team = info.team;
 			// B_ERROR means that no application with the given signature
 			// is running. But we are supposed to return B_BAD_VALUE.
-			if (error == B_ERROR)
+			if (result == B_ERROR)
-				error = B_BAD_VALUE;
+				result = B_BAD_VALUE;
 		} else
-			error = B_BAD_TYPE;
+			result = B_BAD_TYPE;
 	} else {
 		// a team ID is given
-		error = be_roster->GetRunningAppInfo(team, &info);
+		result = be_roster->GetRunningAppInfo(team, &info);
 		// Compare the returned signature with the supplied one.
-		if (error == B_OK && signature && strcasecmp(signature, info.signature))
+		if (result == B_OK && signature != NULL
-			error = B_MISMATCHED_VALUES;
+			&& strcasecmp(signature, info.signature) != 0) {
+			result = B_MISMATCHED_VALUES;
+		}
 	}
 	// check whether the app flags say B_ARGV_ONLY
-	if (error == B_OK && (info.flags & B_ARGV_ONLY)) {
+	if (result == B_OK && (info.flags & B_ARGV_ONLY) != 0) {
-		error = B_BAD_TYPE;
+		result = B_BAD_TYPE;
 		// Set the team ID nevertheless -- that's what Be's implementation
 		// does. Don't know, if that is a bug, but at least it doesn't harm.
 		fTeam = team;
 	}
 	// init our members
-	if (error == B_OK) {
+	if (result == B_OK) {
 		fTeam = team;
 		fPort = info.port;
 		fHandlerToken = B_PREFERRED_TOKEN;
 	}
 
-	// return the error
+	// return the result
-	if (_result)
+	if (_result != NULL)
-		*_result = error;
+		*_result = result;
 }
 
 
-/*!	\brief Initializes the BMessenger to target the local BHandler and/or
+/*!	Initializes the BMessenger to target the local BHandler and/or BLooper.
-	BLooper.
 
 	When a \c NULL handler is supplied, the preferred handler in the given
 	looper is targeted. If no looper is supplied the looper the given handler
@@ -607,37 +382,40 @@ void
 BMessenger::_InitData(const BHandler* handler, const BLooper* looper,
 	status_t* _result)
 {
-	status_t error = (handler || looper ? B_OK : B_BAD_VALUE);
+	status_t result = handler || looper != NULL ? B_OK : B_BAD_VALUE;
-	if (error == B_OK) {
+	if (result == B_OK) {
-		if (handler) {
+		if (handler != NULL) {
 			// BHandler is given, check/retrieve the looper.
-			if (looper) {
+			if (looper != NULL) {
 				if (handler->Looper() != looper)
-					error = B_MISMATCHED_VALUES;
+					result = B_MISMATCHED_VALUES;
 			} else {
 				looper = handler->Looper();
 				if (looper == NULL)
-					error = B_MISMATCHED_VALUES;
+					result = B_MISMATCHED_VALUES;
 			}
 		}
+
 		// set port, token,...
-		if (error == B_OK) {
+		if (result == B_OK) {
 			AutoLocker<BLooperList> locker(gLooperList);
 			if (locker.IsLocked() && gLooperList.IsLooperValid(looper)) {
 				fPort = looper->fMsgPort;
-				fHandlerToken = (handler
+				fHandlerToken = handler != NULL
-					? _get_object_token_(handler) : B_PREFERRED_TOKEN);
+					? _get_object_token_(handler)
+					: B_PREFERRED_TOKEN;
 				fTeam = looper->Team();
 			} else
-				error = B_BAD_VALUE;
+				result = B_BAD_VALUE;
 		}
 	}
-	if (_result)
+
-		*_result = error;
+	if (_result != NULL)
+		*_result = result;
 }
 
 
-/*!	\brief Returns whether the first one of two BMessengers is less than the
+/*!	Returns whether the first one of two BMessengers is less than the
 	second one.
 
 	This method defines an order on BMessengers based on their member
@@ -645,6 +423,7 @@ BMessenger::_InitData(const BHandler* handler, const BLooper* looper,
 
 	\param a The first messenger.
 	\param b The second messenger.
+
 	\return \c true, if \a a is less than \a b, \c false otherwise.
 */
 bool
@@ -667,10 +446,11 @@ operator<(const BMessenger &_a, const BMessenger &_b)
 }
 
 
-/*!	\brief Returns whether two BMessengers have not the same target.
+/*!	Returns whether two BMessengers have not the same target.
 
 	\param a The first messenger.
 	\param b The second messenger.
+
 	\return \c false, if \a a and \a b have the same targets or are both not
 	        properly initialized, \c true otherwise.
 */