i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Style fixes to Messenger, no functional change intended

Browse Source
This commit is contained in:
John Scipione
2015-01-16 16:43:33 -05:00
parent 14d1920039
commit 6fd099550f
2 changed files with 148 additions and 350 deletions
Download Patch File Download Diff File Expand all files Collapse all files
headers/os/app/Messenger.h
+58 -40
View File
@@ -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. * Distributed under the terms of the MIT License.
* *
* Authors: * Authors:
@@ -13,51 +13,65 @@
#include <ByteOrder.h> #include <ByteOrder.h>
#include <Message.h> #include <Message.h>
class BHandler; class BHandler;
class BLooper; class BLooper;
class BMessenger { class BMessenger {
public: public:
BMessenger(); BMessenger();
BMessenger(const char *signature, team_id team = -1, BMessenger(const char* signature,
status_t *result = NULL); team_id team = -1,
BMessenger(const BHandler *handler, const BLooper *looper = NULL, status_t* result = NULL);
status_t *result = NULL); BMessenger(const BHandler* handler,
BMessenger(const BMessenger &from); const BLooper* looper = NULL,
~BMessenger(); status_t* result = NULL);
BMessenger(const BMessenger& other);
~BMessenger();
// Target // Target
bool IsTargetLocal() const; bool IsTargetLocal() const;
BHandler *Target(BLooper **looper) const; BHandler* Target(BLooper **looper) const;
bool LockTarget() const; bool LockTarget() const;
status_t LockTargetWithTimeout(bigtime_t timeout) const; status_t LockTargetWithTimeout(
bigtime_t timeout) const;
// Message sending // 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 // 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 operator==(const BMessenger& other) const;
bool IsValid() const; bool IsValid() const;
team_id Team() const; team_id Team() const;
uint32 HashValue() const; uint32 HashValue() const;
//----- Private or reserved ----------------------------------------- //----- Private or reserved -----------------------------------------
@@ -66,20 +80,24 @@ public:
private: private:
friend class 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,
status_t *result); team_id team, status_t* result);
void _InitData(const BHandler* handler,
const BLooper *looper,
status_t* result);
private: private:
port_id fPort; port_id fPort;
int32 fHandlerToken; int32 fHandlerToken;
team_id fTeam; team_id fTeam;
int32 _reserved[3]; int32 _reserved[3];
}; };
bool operator<(const BMessenger &a, const BMessenger &b); bool operator<(const BMessenger& a, const BMessenger& b);
bool operator!=(const BMessenger &a, const BMessenger &b); bool operator!=(const BMessenger& a, const BMessenger& b);
#endif // _MESSENGER_H #endif // _MESSENGER_H
src/kits/app/Messenger.cpp
+90 -310
View File
@@ -1,5 +1,5 @@
/* /*
* Copyright 2001-2011, Haiku. * Copyright 2001-2011 Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License. * Distributed under the terms of the MIT License.
* *
* Authors: * Authors:
@@ -42,8 +42,6 @@ enum {
}; };
/*! \brief Creates an unitialized BMessenger.
*/
BMessenger::BMessenger() BMessenger::BMessenger()
: :
fPort(-1), fPort(-1),
@@ -53,21 +51,7 @@ BMessenger::BMessenger()
} }
/*! \brief Creates a BMessenger and initializes it to target the already BMessenger::BMessenger(const char* signature, team_id team, status_t* result)
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), fPort(-1),
fHandlerToken(B_NULL_TOKEN), fHandlerToken(B_NULL_TOKEN),
@@ -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, BMessenger::BMessenger(const BHandler* handler, const BLooper* looper,
status_t* _result) 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() BMessenger::~BMessenger()
{ {
} }
@@ -126,12 +89,6 @@ BMessenger::~BMessenger()
// #pragma mark - Target // #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 bool
BMessenger::IsTargetLocal() const BMessenger::IsTargetLocal() const
{ {
@@ -139,23 +96,10 @@ BMessenger::IsTargetLocal() const
} }
/*! \brief Returns the handler and looper targeted by the messenger, if the BHandler*
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 BMessenger::Target(BLooper** _looper) const
{ {
BHandler *handler = NULL; BHandler* handler = NULL;
if (IsTargetLocal() if (IsTargetLocal()
&& (fHandlerToken > B_NULL_TOKEN && (fHandlerToken > B_NULL_TOKEN
|| fHandlerToken == B_PREFERRED_TOKEN)) { || fHandlerToken == B_PREFERRED_TOKEN)) {
@@ -170,21 +114,10 @@ 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 bool
BMessenger::LockTarget() const BMessenger::LockTarget() const
{ {
BLooper *looper = NULL; BLooper* looper = NULL;
Target(&looper); Target(&looper);
if (looper != NULL && looper->Lock()) { if (looper != NULL && looper->Lock()) {
if (looper->fMsgPort == fPort) if (looper->fMsgPort == fPort)
@@ -198,132 +131,59 @@ 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 status_t
BMessenger::LockTargetWithTimeout(bigtime_t timeout) const BMessenger::LockTargetWithTimeout(bigtime_t timeout) const
{ {
BLooper *looper = NULL; BLooper* looper = NULL;
Target(&looper); Target(&looper);
if (looper == NULL) if (looper == NULL)
return B_BAD_VALUE; 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(); looper->Unlock();
return B_BAD_PORT_ID; return B_BAD_PORT_ID;
} }
return error; return result;
} }
// #pragma mark - Message sending // #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 status_t
BMessenger::SendMessage(uint32 command, BHandler *replyTo) const BMessenger::SendMessage(uint32 command, BHandler* replyTo) const
{ {
BMessage message(command); BMessage message(command);
return SendMessage(&message, replyTo); return SendMessage(&message, replyTo);
} }
/*! \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 status_t
BMessenger::SendMessage(BMessage *message, BHandler *replyTo, BMessenger::SendMessage(BMessage* message, BHandler* replyTo,
bigtime_t timeout) const bigtime_t timeout) const
{ {
DBG(OUT("BMessenger::SendMessage2(%.4s)\n", (char*)&message->what)); 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); 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 status_t
BMessenger::SendMessage(BMessage *message, BMessenger replyTo, BMessenger::SendMessage(BMessage* message, BMessenger replyTo,
bigtime_t timeout) const bigtime_t timeout) const
{ {
if (!message) if (message == NULL)
return B_BAD_VALUE; return B_BAD_VALUE;
return BMessage::Private(message).SendMessage(fPort, fTeam, fHandlerToken, return BMessage::Private(message).SendMessage(fPort, fTeam, fHandlerToken,
@@ -331,160 +191,77 @@ 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 status_t
BMessenger::SendMessage(uint32 command, BMessage *reply) const BMessenger::SendMessage(uint32 command, BMessage* reply) const
{ {
BMessage message(command); BMessage message(command);
return SendMessage(&message, reply); 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 status_t
BMessenger::SendMessage(BMessage *message, BMessage *reply, BMessenger::SendMessage(BMessage* message, BMessage* reply,
bigtime_t deliveryTimeout, bigtime_t replyTimeout) const bigtime_t deliveryTimeout, bigtime_t replyTimeout) const
{ {
if (message == NULL || reply == NULL) if (message == NULL || reply == NULL)
return B_BAD_VALUE; 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); 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 // #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 status_t
BMessenger::SetTo(const char *signature, team_id team) BMessenger::SetTo(const char* signature, team_id team)
{ {
status_t result = B_OK; status_t result = B_OK;
_InitData(signature, team, &result); _InitData(signature, team, &result);
return 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 status_t
BMessenger::SetTo(const BHandler* handler, const BLooper* looper) BMessenger::SetTo(const BHandler* handler, const BLooper* looper)
{ {
status_t result = B_OK; status_t result = B_OK;
_InitData(handler, looper, &result); _InitData(handler, looper, &result);
return result; return result;
} }
/*! \brief Makes this BMessenger a copy of the supplied one. BMessenger&
BMessenger::operator=(const BMessenger& other)
\param from the messenger to be copied.
\return A reference to this object.
*/
BMessenger &
BMessenger::operator=(const BMessenger &from)
{ {
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; 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 bool
BMessenger::operator==(const BMessenger &other) const BMessenger::operator==(const BMessenger& other) const
{ {
// Note: The fTeam fields are not compared. // 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 bool
BMessenger::IsValid() const 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 team_id
BMessenger::Team() const BMessenger::Team() const
{ {
@@ -514,9 +287,9 @@ BMessenger::HashValue() const
// #pragma mark - Private or reserved // #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 team The target's team.
\param port The target looper port. \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. team ID of a target.
When only a signature is given, and multiple instances of the application 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 void
BMessenger::_InitData(const char* signature, team_id team, status_t* _result) 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 // get an app_info
app_info info; app_info info;
if (team < 0) { if (team < 0) {
// no team ID given // no team ID given
if (signature) { if (signature != NULL) {
error = be_roster->GetAppInfo(signature, &info); result = be_roster->GetAppInfo(signature, &info);
team = info.team; team = info.team;
// B_ERROR means that no application with the given signature // B_ERROR means that no application with the given signature
// is running. But we are supposed to return B_BAD_VALUE. // 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 } else
error = B_BAD_TYPE; result = B_BAD_TYPE;
} else { } else {
// a team ID is given // 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. // 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 // 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 // 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. // does. Don't know, if that is a bug, but at least it doesn't harm.
fTeam = team; fTeam = team;
} }
// init our members // init our members
if (error == B_OK) { if (result == B_OK) {
fTeam = team; fTeam = team;
fPort = info.port; fPort = info.port;
fHandlerToken = B_PREFERRED_TOKEN; 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 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 looper is targeted. If no looper is supplied the looper the given handler
@@ -601,43 +376,46 @@ BMessenger::_InitData(const char* signature, team_id team, status_t* _result)
\param handler The target handler. May be \c NULL. \param handler The target handler. May be \c NULL.
\param looper The target looper. 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 \param result An optional pointer to a pre-allocated status_t into which
the result of the initialization is written. the result of the initialization is written.
*/ */
void void
BMessenger::_InitData(const BHandler* handler, const BLooper* looper, BMessenger::_InitData(const BHandler* handler, const BLooper* looper,
status_t* _result) 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. // BHandler is given, check/retrieve the looper.
if (looper) { if (looper != NULL) {
if (handler->Looper() != looper) if (handler->Looper() != looper)
error = B_MISMATCHED_VALUES; result = B_MISMATCHED_VALUES;
} else { } else {
looper = handler->Looper(); looper = handler->Looper();
if (looper == NULL) if (looper == NULL)
error = B_MISMATCHED_VALUES; result = B_MISMATCHED_VALUES;
} }
} }
// set port, token,... // set port, token,...
if (error == B_OK) { if (result == B_OK) {
AutoLocker<BLooperList> locker(gLooperList); AutoLocker<BLooperList> locker(gLooperList);
if (locker.IsLocked() && gLooperList.IsLooperValid(looper)) { if (locker.IsLocked() && gLooperList.IsLooperValid(looper)) {
fPort = looper->fMsgPort; 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(); fTeam = looper->Team();
} else } 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. second one.
This method defines an order on BMessengers based on their member This method defines an order on BMessengers based on their member
@@ -645,10 +423,11 @@ BMessenger::_InitData(const BHandler* handler, const BLooper* looper,
\param a The first messenger. \param a The first messenger.
\param b The second messenger. \param b The second messenger.
\return \c true, if \a a is less than \a b, \c false otherwise. \return \c true, if \a a is less than \a b, \c false otherwise.
*/ */
bool bool
operator<(const BMessenger &_a, const BMessenger &_b) operator<(const BMessenger& _a, const BMessenger& _b)
{ {
BMessenger::Private a(const_cast<BMessenger&>(_a)); BMessenger::Private a(const_cast<BMessenger&>(_a));
BMessenger::Private b(const_cast<BMessenger&>(_b)); BMessenger::Private b(const_cast<BMessenger&>(_b));
@@ -667,15 +446,16 @@ 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 a The first messenger.
\param b The second messenger. \param b The second messenger.
\return \c false, if \a a and \a b have the same targets or are both not \return \c false, if \a a and \a b have the same targets or are both not
properly initialized, \c true otherwise. properly initialized, \c true otherwise.
*/ */
bool bool
operator!=(const BMessenger &a, const BMessenger &b) operator!=(const BMessenger& a, const BMessenger& b)
{ {
return !(a == b); return !(a == b);
} }