mtsEventReceiver.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */

/*

  Author(s):  Peter Kazanzides
  Created on: 2010-09-24

  (C) Copyright 2010-2014 Johns Hopkins University (JHU), All Rights Reserved.

--- begin cisst license - do not edit ---

This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.

--- end cisst license ---
*/


#ifndef _mtsEventReceiver_h
#define _mtsEventReceiver_h

#include <cisstMultiTask/mtsInterfaceRequired.h>
#include <cisstOSAbstraction/osaForwardDeclarations.h>

// Always include last
#include <cisstMultiTask/mtsExport.h>


// EventReceivers must be added before Bind (should add check for InterfaceProvidedOrOutput==0)
// EventHandlers can be added at any time.
// When Bind called,
//    if no EventReceiver, directly add EventHandler
//    if EventReceiver, set handler in it

class CISST_EXPORT mtsEventReceiverBase {
protected:
    std::string Name;
    mtsInterfaceRequired * Required;   // Pointer to the required interface
    osaThreadSignal * EventSignal;
    bool Waiting;
    bool OwnEventSignal;   // true if we created our own thread signal

    bool CheckRequired() const;
    bool WaitCommon();

public:
    mtsEventReceiverBase();
    virtual ~mtsEventReceiverBase();

    void SetName(const std::string &name) { Name = name; }
    virtual std::string GetName() const { return Name; }

    virtual void SetRequired(const std::string &name, mtsInterfaceRequired *req);

    virtual void SetThreadSignal(osaThreadSignal *signal);

    virtual bool Wait();

    virtual bool WaitWithTimeout(double timeoutInSec);

    virtual void Detach();

    virtual void ToStream(std::ostream & outputStream) const = 0;
};


inline std::ostream & operator << (std::ostream & output,
                                   const mtsEventReceiverBase & receiver) {
    receiver.ToStream(output);
    return output;
}

class CISST_EXPORT mtsEventReceiverVoid : public mtsEventReceiverBase {
protected:
    mtsCommandVoid * Command;      // Command object for calling EventHandler method
    mtsCommandVoid * UserHandler;  // User supplied event handler

    // This one always gets added non-queued
    void EventHandler(void);

public:
    mtsEventReceiverVoid();
    ~mtsEventReceiverVoid();

    mtsCommandVoid * GetCommand(void);

    void SetHandlerCommand(mtsCommandVoid * commandHandler);

    // Same functionality as mtsInterfaceRequired::AddEventHandlerVoid.
    template <class __classType>
    inline mtsCommandVoid * SetHandler(void (__classType::*method)(void),
                                       __classType * classInstantiation,
                                       mtsEventQueueingPolicy queueingPolicy = MTS_INTERFACE_EVENT_POLICY) {
        return CheckRequired() ? (Required->AddEventHandlerVoid(method, classInstantiation, this->GetName(), queueingPolicy)) : 0;
    }

    inline mtsCommandVoid * SetHandler(void (*function)(void),
                                       mtsEventQueueingPolicy queueingPolicy = MTS_INTERFACE_EVENT_POLICY) {
        return CheckRequired() ? (Required->AddEventHandlerVoid(function, this->GetName(), queueingPolicy)) : 0;
    }

    bool RemoveHandler(void);

    void ToStream(std::ostream & outputStream) const;
};

class CISST_EXPORT mtsEventReceiverWrite : public mtsEventReceiverBase {
protected:
    mtsCommandWriteBase *Command;      // Command object for calling EventHandler method
    mtsCommandWriteBase *UserHandler;  // User supplied event handler
    mtsGenericObject *ArgPtr;

    // This one always gets added non-queued
    void EventHandler(const mtsGenericObject &arg);

public:
    mtsEventReceiverWrite();
    ~mtsEventReceiverWrite();

    mtsCommandWriteBase *GetCommand();

    void SetHandlerCommand(mtsCommandWriteBase * commandHandler);

    // Same functionality as mtsInterfaceRequired::AddEventHandlerWrite.
    template <class __classType, class __argumentType>
    inline mtsCommandWriteBase * SetHandler(void (__classType::*method)(const __argumentType &),
                                            __classType * classInstantiation,
                                            mtsEventQueueingPolicy queueingPolicy = MTS_INTERFACE_EVENT_POLICY) {
        return CheckRequired() ? (Required->AddEventHandlerWrite(method, classInstantiation, this->GetName(), queueingPolicy)) : 0;
    }

    // PK: Do we need the "generic" version (AddEventHandlerWriteGeneric)?


    // Note that we are using the Wait and WaitWithTimeout member functions from the base class.
    using mtsEventReceiverBase::Wait;
    using mtsEventReceiverBase::WaitWithTimeout;

    virtual bool Wait(mtsGenericObject &obj);
    virtual bool WaitWithTimeout(double timeoutInSec, mtsGenericObject &obj);

    //PK: might be nice to have this
    //const mtsGenericObject *GetArgumentPrototype() const;

    bool RemoveHandler(void);

    void ToStream(std::ostream & outputStream) const;
};


#endif // _mtsEventReceiver_h