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

Style fixes to BMessageRunner, no functional changes intended

Browse Source
This commit is contained in:
John Scipione
2015-01-16 18:00:27 -05:00
parent 2eb2dcfabe
commit 1f4de50d39
2 changed files with 89 additions and 228 deletions
Download Patch File Download Diff File Expand all files Collapse all files
headers/os/app/MessageRunner.h
+2 -3
View File
@@ -1,5 +1,5 @@
/* /*
* Copyright 2001-2010, Haiku, Inc. * Copyright 2001-2010 Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License. * Distributed under the terms of the MIT License.
*/ */
#ifndef _MESSAGE_RUNNER_H #ifndef _MESSAGE_RUNNER_H
@@ -41,8 +41,7 @@ public:
private: private:
BMessageRunner(const BMessageRunner &); BMessageRunner(const BMessageRunner &);
BMessageRunner &operator=( BMessageRunner& operator=(const BMessageRunner&);
const BMessageRunner &);
static int32 _RegisterRunner(BMessenger target, static int32 _RegisterRunner(BMessenger target,
const BMessage* message, bigtime_t interval, const BMessage* message, bigtime_t interval,
src/kits/app/MessageRunner.cpp
+73 -211
View File
@@ -1,5 +1,5 @@
/* /*
* Copyright 2001-2010, Haiku, Inc. * Copyright 2001-2010 Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License. * Distributed under the terms of the MIT License.
* *
* Authors: * Authors:
@@ -19,25 +19,6 @@
using namespace BPrivate; using namespace BPrivate;
/*! \brief Creates and initializes a new BMessageRunner.
The target for replies to the delivered message(s) is \c be_app_messenger.
The success of the initialization can (and should) be asked for via
InitCheck(). This object will not take ownership of the \a message, you
may freely change or delete it after creation.
\note As soon as the last message has been sent, the message runner
becomes unusable. InitCheck() will still return \c B_OK, but
SetInterval(), SetCount() and GetInfo() will fail.
\param target Target of the message(s).
\param message The message to be sent to the target.
\param interval Period of time before the first message is sent and
between messages (if more than one shall be sent) in microseconds.
\param count Specifies how many times the message shall be sent.
A value less than \c 0 for an unlimited number of repetitions.
*/
BMessageRunner::BMessageRunner(BMessenger target, const BMessage* message, BMessageRunner::BMessageRunner(BMessenger target, const BMessage* message,
bigtime_t interval, int32 count) bigtime_t interval, int32 count)
: :
@@ -47,25 +28,6 @@ BMessageRunner::BMessageRunner(BMessenger target, const BMessage* message,
} }
/*! \brief Creates and initializes a new BMessageRunner.
The target for replies to the delivered message(s) is \c be_app_messenger.
The success of the initialization can (and should) be asked for via
InitCheck(). This object will not take ownership of the \a message, you
may freely change or delete it after creation.
\note As soon as the last message has been sent, the message runner
becomes unusable. InitCheck() will still return \c B_OK, but
SetInterval(), SetCount() and GetInfo() will fail.
\param target Target of the message(s).
\param message The message to be sent to the target.
\param interval Period of time before the first message is sent and
between messages (if more than one shall be sent) in microseconds.
\param count Specifies how many times the message shall be sent.
A value less than \c 0 for an unlimited number of repetitions.
*/
BMessageRunner::BMessageRunner(BMessenger target, const BMessage& message, BMessageRunner::BMessageRunner(BMessenger target, const BMessage& message,
bigtime_t interval, int32 count) bigtime_t interval, int32 count)
: :
@@ -75,27 +37,6 @@ BMessageRunner::BMessageRunner(BMessenger target, const BMessage& message,
} }
/*! \brief Creates and initializes a new BMessageRunner.
This constructor version additionally allows to specify the target for
replies to the delivered message(s).
The success of the initialization can (and should) be asked for via
InitCheck(). This object will not take ownership of the \a message, you
may freely change or delete it after creation.
\note As soon as the last message has been sent, the message runner
becomes unusable. InitCheck() will still return \c B_OK, but
SetInterval(), SetCount() and GetInfo() will fail.
\param target Target of the message(s).
\param message The message to be sent to the target.
\param interval Period of time before the first message is sent and
between messages (if more than one shall be sent) in microseconds.
\param count Specifies how many times the message shall be sent.
A value less than \c 0 for an unlimited number of repetitions.
\param replyTo Target replies to the delivered message(s) shall be sent to.
*/
BMessageRunner::BMessageRunner(BMessenger target, const BMessage* message, BMessageRunner::BMessageRunner(BMessenger target, const BMessage* message,
bigtime_t interval, int32 count, BMessenger replyTo) bigtime_t interval, int32 count, BMessenger replyTo)
: :
@@ -105,27 +46,6 @@ BMessageRunner::BMessageRunner(BMessenger target, const BMessage* message,
} }
/*! \brief Creates and initializes a new BMessageRunner.
This constructor version additionally allows to specify the target for
replies to the delivered message(s).
The success of the initialization can (and should) be asked for via
InitCheck(). This object will not take ownership of the \a message, you
may freely change or delete it after creation.
\note As soon as the last message has been sent, the message runner
becomes unusable. InitCheck() will still return \c B_OK, but
SetInterval(), SetCount() and GetInfo() will fail.
\param target Target of the message(s).
\param message The message to be sent to the target.
\param interval Period of time before the first message is sent and
between messages (if more than one shall be sent) in microseconds.
\param count Specifies how many times the message shall be sent.
A value less than \c 0 for an unlimited number of repetitions.
\param replyTo Target replies to the delivered message(s) shall be sent to.
*/
BMessageRunner::BMessageRunner(BMessenger target, const BMessage& message, BMessageRunner::BMessageRunner(BMessenger target, const BMessage& message,
bigtime_t interval, int32 count, BMessenger replyTo) bigtime_t interval, int32 count, BMessenger replyTo)
: :
@@ -135,8 +55,6 @@ BMessageRunner::BMessageRunner(BMessenger target, const BMessage& message,
} }
/*! \brief Frees all resources associated with the object.
*/
BMessageRunner::~BMessageRunner() BMessageRunner::~BMessageRunner()
{ {
if (fToken < B_OK) if (fToken < B_OK)
@@ -144,26 +62,17 @@ BMessageRunner::~BMessageRunner()
// compose the request message // compose the request message
BMessage request(B_REG_UNREGISTER_MESSAGE_RUNNER); BMessage request(B_REG_UNREGISTER_MESSAGE_RUNNER);
status_t error = request.AddInt32("token", fToken); status_t result = request.AddInt32("token", fToken);
// send the request // send the request
BMessage reply; BMessage reply;
if (error == B_OK) if (result == B_OK)
error = BRoster::Private().SendTo(&request, &reply, false); result = BRoster::Private().SendTo(&request, &reply, false);
// ignore the reply, we can't do anything anyway // ignore the reply, we can't do anything anyway
} }
/*! \brief Returns the status of the initialization.
\note As soon as the last message has been sent, the message runner
becomes unusable. InitCheck() will still return \c B_OK, but
SetInterval(), SetCount() and GetInfo() will fail.
\return \c B_OK, if the object is properly initialized, an error code
otherwise.
*/
status_t status_t
BMessageRunner::InitCheck() const BMessageRunner::InitCheck() const
{ {
@@ -171,14 +80,6 @@ BMessageRunner::InitCheck() const
} }
/*! \brief Sets the interval of time between messages.
\param interval The new interval in microseconds.
\return
- \c B_OK: Everything went fine.
- \c B_NO_INIT: The message runner is not properly initialized.
- \c B_BAD_VALUE: \a interval is \c 0 or negative, or the message runner
has already sent all messages to be sent and has become unusable.
*/
status_t status_t
BMessageRunner::SetInterval(bigtime_t interval) BMessageRunner::SetInterval(bigtime_t interval)
{ {
@@ -186,15 +87,6 @@ BMessageRunner::SetInterval(bigtime_t interval)
} }
/*! \brief Sets the number of times message shall be sent.
\param count Specifies how many times the message shall be sent.
A value less than \c 0 for an unlimited number of repetitions.
- \c B_BAD_VALUE: The message runner has already sent all messages to be
sent and has become unusable.
\return
- \c B_OK: Everything went fine.
- \c B_NO_INIT: The message runner is not properly initialized.
*/
status_t status_t
BMessageRunner::SetCount(int32 count) BMessageRunner::SetCount(int32 count)
{ {
@@ -202,104 +94,67 @@ BMessageRunner::SetCount(int32 count)
} }
/*! \brief Returns the time interval between two messages and the number of
times the message has still to be sent.
Both parameters (\a interval and \a count) may be \c NULL.
\param interval Pointer to a pre-allocated bigtime_t variable to be set
to the time interval. May be \c NULL.
\param count Pointer to a pre-allocated int32 variable to be set
to the number of times the message has still to be sent.
May be \c NULL.
\return
- \c B_OK: Everything went fine.
- \c B_BAD_VALUE: The message runner is not longer valid. All the
messages that had to be sent have already been sent.
*/
status_t status_t
BMessageRunner::GetInfo(bigtime_t* interval, int32* count) const BMessageRunner::GetInfo(bigtime_t* interval, int32* count) const
{ {
status_t error = (fToken >= 0 ? B_OK : B_BAD_VALUE); status_t result = fToken >= 0 ? B_OK : B_BAD_VALUE;
// compose the request message // compose the request message
BMessage request(B_REG_GET_MESSAGE_RUNNER_INFO); BMessage request(B_REG_GET_MESSAGE_RUNNER_INFO);
if (error == B_OK) if (result == B_OK)
error = request.AddInt32("token", fToken); result = request.AddInt32("token", fToken);
// send the request // send the request
BMessage reply; BMessage reply;
if (error == B_OK) if (result == B_OK)
error = BRoster::Private().SendTo(&request, &reply, false); result = BRoster::Private().SendTo(&request, &reply, false);
// evaluate the reply // evaluate the reply
if (error == B_OK) { if (result == B_OK) {
if (reply.what == B_REG_SUCCESS) { if (reply.what == B_REG_SUCCESS) {
// count // count
int32 _count; int32 _count;
if (reply.FindInt32("count", &_count) == B_OK) { if (reply.FindInt32("count", &_count) == B_OK) {
if (count) if (count != 0)
*count = _count; *count = _count;
} else } else
error = B_ERROR; result = B_ERROR;
// interval // interval
bigtime_t _interval; bigtime_t _interval;
if (reply.FindInt64("interval", &_interval) == B_OK) { if (reply.FindInt64("interval", &_interval) == B_OK) {
if (interval) if (interval != 0)
*interval = _interval; *interval = _interval;
} else } else
error = B_ERROR; result = B_ERROR;
} else { } else {
if (reply.FindInt32("error", &error) != B_OK) if (reply.FindInt32("error", &result) != B_OK)
error = B_ERROR; result = B_ERROR;
} }
} }
return error;
return result;
} }
/*! \brief Creates and initializes a detached BMessageRunner.
You cannot alter the runner after the creation, and it will be deleted
automatically once it is done.
The target for replies to the delivered message(s) is \c be_app_messenger.
\param target Target of the message(s).
\param message The message to be sent to the target.
\param interval Period of time before the first message is sent and
between messages (if more than one shall be sent) in microseconds.
\param count Specifies how many times the message shall be sent.
A value less than \c 0 for an unlimited number of repetitions.
*/
/*static*/ status_t /*static*/ status_t
BMessageRunner::StartSending(BMessenger target, const BMessage* message, BMessageRunner::StartSending(BMessenger target, const BMessage* message,
bigtime_t interval, int32 count) bigtime_t interval, int32 count)
{ {
int32 token = _RegisterRunner(target, message, interval, count, true, int32 token = _RegisterRunner(target, message, interval, count, true,
be_app_messenger); be_app_messenger);
return token >= B_OK ? B_OK : token; return token >= B_OK ? B_OK : token;
} }
/*! \brief Creates and initializes a detached BMessageRunner.
You cannot alter the runner after the creation, and it will be deleted
automatically once it is done.
\param target Target of the message(s).
\param message The message to be sent to the target.
\param interval Period of time before the first message is sent and
between messages (if more than one shall be sent) in microseconds.
\param count Specifies how many times the message shall be sent.
A value less than \c 0 for an unlimited number of repetitions.
\param replyTo Target replies to the delivered message(s) shall be sent to.
*/
/*static*/ status_t /*static*/ status_t
BMessageRunner::StartSending(BMessenger target, const BMessage* message, BMessageRunner::StartSending(BMessenger target, const BMessage* message,
bigtime_t interval, int32 count, BMessenger replyTo) bigtime_t interval, int32 count, BMessenger replyTo)
{ {
int32 token = _RegisterRunner(target, message, interval, count, true, replyTo); int32 token = _RegisterRunner(target, message, interval, count, true,
replyTo);
return token >= B_OK ? B_OK : token; return token >= B_OK ? B_OK : token;
} }
@@ -313,16 +168,15 @@ void BMessageRunner::_ReservedMessageRunner5() {}
void BMessageRunner::_ReservedMessageRunner6() {} void BMessageRunner::_ReservedMessageRunner6() {}
/*! \brief Privatized copy constructor to prevent usage. //! Privatized copy constructor to prevent usage.
*/
BMessageRunner::BMessageRunner(const BMessageRunner &) BMessageRunner::BMessageRunner(const BMessageRunner &)
: fToken(-1) :
fToken(-1)
{ {
} }
/*! \brief Privatized assignment operator to prevent usage. //! Privatized assignment operator to prevent usage.
*/
BMessageRunner& BMessageRunner&
BMessageRunner::operator=(const BMessageRunner&) BMessageRunner::operator=(const BMessageRunner&)
{ {
@@ -330,7 +184,7 @@ BMessageRunner::operator=(const BMessageRunner &)
} }
/*! \brief Initializes the BMessageRunner. /*! Initializes the BMessageRunner.
The success of the initialization can (and should) be asked for via The success of the initialization can (and should) be asked for via
InitCheck(). InitCheck().
@@ -355,7 +209,7 @@ BMessageRunner::_InitData(BMessenger target, const BMessage* message,
} }
/*! \brief Registers the BMessageRunner in the registrar. /*! Registers the BMessageRunner in the registrar.
\param target Target of the message(s). \param target Target of the message(s).
\param message The message to be sent to the target. \param message The message to be sent to the target.
@@ -372,51 +226,56 @@ BMessageRunner::_InitData(BMessenger target, const BMessage* message,
BMessageRunner::_RegisterRunner(BMessenger target, const BMessage* message, BMessageRunner::_RegisterRunner(BMessenger target, const BMessage* message,
bigtime_t interval, int32 count, bool detach, BMessenger replyTo) bigtime_t interval, int32 count, bool detach, BMessenger replyTo)
{ {
status_t error = B_OK; status_t result = B_OK;
if (message == NULL || count == 0 || (count < 0 && detach)) if (message == NULL || count == 0 || (count < 0 && detach))
error = B_BAD_VALUE; result = B_BAD_VALUE;
// compose the request message // compose the request message
BMessage request(B_REG_REGISTER_MESSAGE_RUNNER); BMessage request(B_REG_REGISTER_MESSAGE_RUNNER);
if (error == B_OK) if (result == B_OK)
error = request.AddInt32("team", BPrivate::current_team()); result = request.AddInt32("team", BPrivate::current_team());
if (error == B_OK)
error = request.AddMessenger("target", target); if (result == B_OK)
if (error == B_OK) result = request.AddMessenger("target", target);
error = request.AddMessage("message", message);
if (error == B_OK) if (result == B_OK)
error = request.AddInt64("interval", interval); result = request.AddMessage("message", message);
if (error == B_OK)
error = request.AddInt32("count", count); if (result == B_OK)
if (error == B_OK) result = request.AddInt64("interval", interval);
error = request.AddMessenger("reply_target", replyTo);
if (result == B_OK)
result = request.AddInt32("count", count);
if (result == B_OK)
result = request.AddMessenger("reply_target", replyTo);
// send the request // send the request
BMessage reply; BMessage reply;
if (error == B_OK) if (result == B_OK)
error = BRoster::Private().SendTo(&request, &reply, false); result = BRoster::Private().SendTo(&request, &reply, false);
int32 token; int32 token;
// evaluate the reply // evaluate the reply
if (error == B_OK) { if (result == B_OK) {
if (reply.what == B_REG_SUCCESS) { if (reply.what == B_REG_SUCCESS) {
if (reply.FindInt32("token", &token) != B_OK) if (reply.FindInt32("token", &token) != B_OK)
error = B_ERROR; result = B_ERROR;
} else { } else {
if (reply.FindInt32("error", &error) != B_OK) if (reply.FindInt32("error", &result) != B_OK)
error = B_ERROR; result = B_ERROR;
} }
} }
if (error == B_OK) if (result == B_OK)
return token; return token;
return error; return result;
} }
/*! \brief Sets the message runner's interval and count parameters. /*! Sets the message runner's interval and count parameters.
The parameters \a resetInterval and \a resetCount specify whether The parameters \a resetInterval and \a resetCount specify whether
the interval or the count parameter respectively shall be reset. the interval or the count parameter respectively shall be reset.
@@ -431,9 +290,10 @@ BMessageRunner::_RegisterRunner(BMessenger target, const BMessage* message,
otherwise -- then \a count is ignored. otherwise -- then \a count is ignored.
\param count Specifies how many times the message shall be sent. \param count Specifies how many times the message shall be sent.
A value less than \c 0 for an unlimited number of repetitions. A value less than \c 0 for an unlimited number of repetitions.
\return
- \c B_OK: Everything went fine. \return A status code.
- \c B_BAD_VALUE: The message runner is not longer valid. All the \retval B_OK Everything went fine.
\retval B_BAD_VALUE The message runner is not longer valid. All the
messages that had to be sent have already been sent. Or both messages that had to be sent have already been sent. Or both
\a resetInterval and \a resetCount are \c false. \a resetInterval and \a resetCount are \c false.
*/ */
@@ -446,23 +306,25 @@ BMessageRunner::_SetParams(bool resetInterval, bigtime_t interval,
// compose the request message // compose the request message
BMessage request(B_REG_SET_MESSAGE_RUNNER_PARAMS); BMessage request(B_REG_SET_MESSAGE_RUNNER_PARAMS);
status_t error = request.AddInt32("token", fToken); status_t result = request.AddInt32("token", fToken);
if (error == B_OK && resetInterval) if (result == B_OK && resetInterval)
error = request.AddInt64("interval", interval); result = request.AddInt64("interval", interval);
if (error == B_OK && resetCount)
error = request.AddInt32("count", count); if (result == B_OK && resetCount)
result = request.AddInt32("count", count);
// send the request // send the request
BMessage reply; BMessage reply;
if (error == B_OK) if (result == B_OK)
error = BRoster::Private().SendTo(&request, &reply, false); result = BRoster::Private().SendTo(&request, &reply, false);
// evaluate the reply // evaluate the reply
if (error == B_OK) { if (result == B_OK) {
if (reply.what != B_REG_SUCCESS) { if (reply.what != B_REG_SUCCESS) {
if (reply.FindInt32("error", &error) != B_OK) if (reply.FindInt32("error", &result) != B_OK)
error = B_ERROR; result = B_ERROR;
} }
} }
return error;
return result;
} }