// SMInvoker.cpp

#include "SMInvoker.h"
#include "SMMessages.h"

// SMInvoker

// constructor
SMInvoker::SMInvoker()
                 : fReplyMessage(NULL)
{
}

// destructor
SMInvoker::~SMInvoker()
{
        delete fReplyMessage;
}

// ReplySuccess
bool
SMInvoker::ReplySuccess()
{
        return (fReplyMessage && fReplyMessage->what == MSG_REPLY);
}

// DirectReply
bool
SMInvoker::DirectReply()
{
        return fReplyMessage;
}


// SMInvoker1

// constructor
SMInvoker1::SMInvoker1(bool useReplyTo)
                  : SMInvoker(),
                        fUseReplyTo(useReplyTo)
{
}

// Invoke
status_t
SMInvoker1::Invoke(BMessenger &target, BHandler *replyHandler,
                                   BMessenger &replyMessenger)
{
        BHandler *replyTo = (fUseReplyTo ? replyHandler : NULL);
        status_t result = target.SendMessage(MSG_TEST, replyTo);
        return result;
}


// SMInvoker2

// constructor
SMInvoker2::SMInvoker2(bool useMessage, bool useReplyTo, bigtime_t timeout)
                  : SMInvoker(),
                        fUseMessage(useMessage),
                        fUseReplyTo(useReplyTo),
                        fTimeout(timeout)
{
}

// Invoke
status_t
SMInvoker2::Invoke(BMessenger &target, BHandler *replyHandler,
                                   BMessenger &replyMessenger)
{
        BHandler *replyTo = (fUseReplyTo ? replyHandler : NULL);
        BMessage _message(MSG_TEST);
        BMessage *message = (fUseMessage ? &_message : NULL);
        status_t result = target.SendMessage(message, replyTo, fTimeout);
        return result;
}


// SMInvoker3

// constructor
SMInvoker3::SMInvoker3(bool useMessage, bool useReplyTo, bigtime_t timeout)
                  : SMInvoker(),
                        fUseMessage(useMessage),
                        fUseReplyTo(useReplyTo),
                        fTimeout(timeout)
{
}

// Invoke
status_t
SMInvoker3::Invoke(BMessenger &target, BHandler *replyHandler,
                                   BMessenger &replyMessenger)
{
        BMessenger badMessenger;
        BMessenger &replyTo = (fUseReplyTo ? replyMessenger : badMessenger);
        BMessage _message(MSG_TEST);
        BMessage *message = (fUseMessage ? &_message : NULL);
        status_t result = target.SendMessage(message, replyTo, fTimeout);
        return result;
}


// SMInvoker4

// constructor
SMInvoker4::SMInvoker4(bool useReply)
                  : SMInvoker(),
                        fUseReply(useReply)
{
}

// Invoke
status_t
SMInvoker4::Invoke(BMessenger &target, BHandler *replyHandler,
                                   BMessenger &replyMessenger)
{
        if (fUseReply)
                fReplyMessage = new BMessage(uint32(0));
        status_t result = target.SendMessage(MSG_TEST, fReplyMessage);
        return result;
}


// SMInvoker5

// constructor
SMInvoker5::SMInvoker5(bool useMessage, bool useReply,
                                           bigtime_t deliveryTimeout, bigtime_t replyTimeout)
                  : SMInvoker(),
                        fUseMessage(useMessage),
                        fUseReply(useReply),
                        fDeliveryTimeout(deliveryTimeout),
                        fReplyTimeout(replyTimeout)
{
}

// Invoke
status_t
SMInvoker5::Invoke(BMessenger &target, BHandler *replyHandler,
                                   BMessenger &replyMessenger)
{
        if (fUseReply)
                fReplyMessage = new BMessage(uint32(0));
        BMessage _message(MSG_TEST);
        BMessage *message = (fUseMessage ? &_message : NULL);
        status_t result = target.SendMessage(message, fReplyMessage,
                                                                                 fDeliveryTimeout, fReplyTimeout);
        return result;
}