IOPins.h

Go to the documentation of this file.

#ifndef IOPINS_H
#define IOPINS_H

#include <vrecko/Export>
#include <vrecko/Message.h>
#include <vrecko/BaseClass.h>
#include <vrecko/World.h>

namespace vrecko {

class BaseClass;
class Ability;
class EnvironmentObject;


template <class _MessageType>
class InputPin : public InputPinBase {
public:
    typedef void (BaseClass::*PROCESSING_METHOD) (_MessageType *message);

    InputPin(BaseClass *_owner, const char *_inputName, PROCESSING_METHOD _methodForProcessing) { coreInit(_owner, _inputName, _methodForProcessing); }
    ~InputPin() {
    }

    virtual VreckoMessage* createCompatibleMessage() { return new _MessageType; }

    virtual void processMessage(VreckoMessage *message) { if (methodForProcessing) { (owner->*methodForProcessing)((_MessageType*)message); } }

protected:
    void coreInit(BaseClass *_owner, const char *_inputName, PROCESSING_METHOD _methodForProcessing) {
        owner = _owner;
        pinName = _inputName;
        methodForProcessing = _methodForProcessing;
    }

    PROCESSING_METHOD methodForProcessing;
};


template <class _MessageType>
class OutputPin : public OutputPinBase {
public:
    OutputPin(BaseClass *_owner, const char *_outputName) {
        owner = _owner;
        pinName = _outputName;
    }

    ~OutputPin() {
    }

    virtual VreckoMessage* createCompatibleMessage() { return new _MessageType; }

    inline bool send(_MessageType *messageToBeSent, EventType eventType = EXPRESS_EVENT) {
        if (senderStringWithOutputName.empty()) {
            // first-time initialization (caching the result)
            senderStringWithOutputName = owner->getSenderString() + "#" + pinName;
        }
        return world->getEventDispatcherPtr()->reportEvent(senderStringWithOutputName, messageToBeSent, eventType);
    }

protected:
    std::string senderStringWithOutputName; // initialized after the first call to send()
};




template <class _MessageType, class _ReturningMessageType>
class RequestInputPin : public RequestInputPinBase {
public:
    typedef osg::ref_ptr<_ReturningMessageType> (BaseClass::*PROCESSING_METHOD) (_MessageType *message);

    RequestInputPin(BaseClass *_owner, const char *_requestInputName, PROCESSING_METHOD _methodForProcessing) { coreInit(_owner, _requestInputName, _methodForProcessing); }

    ~RequestInputPin() {
    }

    virtual VreckoMessage* createCompatibleMessage() { return new _MessageType; }
    virtual VreckoMessage* createReturningCompatibleMessage() { return new _ReturningMessageType; }

    virtual osg::ref_ptr<VreckoMessage> processRequest(VreckoMessage *message) { return (!methodForProcessing) ? NULL : (owner->*methodForProcessing)((_MessageType*)message); }
//  inline const PROCESSING_METHOD getMethodForProcessing() const { return methodForProcessing; }

protected:
    void coreInit(BaseClass *_owner, const char *_requestInputName, PROCESSING_METHOD _methodForProcessing) {
        owner = _owner;
        pinName = _requestInputName;
        methodForProcessing = _methodForProcessing;
    }

    PROCESSING_METHOD methodForProcessing;
};




template <class _MessageType, class _ReturningMessageType>
class RequestOutputPin : public RequestOutputPinBase {
public:
    RequestOutputPin(BaseClass *_owner, const char *_requestOutputName) {
        owner = _owner;
        pinName = _requestOutputName;
    }

    ~RequestOutputPin() {
    }

    virtual VreckoMessage* createCompatibleMessage() { return new _MessageType; }
    virtual VreckoMessage* createReturningCompatibleMessage() { return new _ReturningMessageType; }

    inline osg::ref_ptr<_ReturningMessageType> request(_MessageType *messageToBeSent) {
        if (senderStringWithOutputName.empty()) {
            // first-time initialization (caching the result)
            senderStringWithOutputName = owner->getSenderString() + "#" + pinName;
        }
        return (_ReturningMessageType*)(world->getEventDispatcherPtr()->request(senderStringWithOutputName, messageToBeSent).get());
    }

protected:
    std::string senderStringWithOutputName; // initialized after the first call to send()
};




// Explicit instantiation of pins for usual messages.
// This is not necessary and also it increases the size of vrecko.lib, but other
// do not need to compile it, just overtake the compiled form from the vrecko.lib library.
// (I hope I did this right as I don't know how to verify it.)
template class VRECKO_EXPORT OutputPin<MessageBool>;
template class VRECKO_EXPORT InputPin<MessageBool>;

template class VRECKO_EXPORT OutputPin<MessageInt>;
template class VRECKO_EXPORT InputPin<MessageInt>;

template class VRECKO_EXPORT OutputPin<MessageUnsignedInt>;
template class VRECKO_EXPORT InputPin<MessageUnsignedInt>;

template class VRECKO_EXPORT OutputPin<MessageFloat>;
template class VRECKO_EXPORT InputPin<MessageFloat>;

template class VRECKO_EXPORT OutputPin<MessageObjectID>;
template class VRECKO_EXPORT InputPin<MessageObjectID>;

template class VRECKO_EXPORT OutputPin<MessageString>;
template class VRECKO_EXPORT InputPin<MessageString>;

template class VRECKO_EXPORT OutputPin<MessageVec2>;
template class VRECKO_EXPORT InputPin<MessageVec2>;

template class VRECKO_EXPORT OutputPin<MessageVec3>;
template class VRECKO_EXPORT InputPin<MessageVec3>;

template class VRECKO_EXPORT OutputPin<MessageVec4>;
template class VRECKO_EXPORT InputPin<MessageVec4>;

template class VRECKO_EXPORT OutputPin<MessageQuat>;
template class VRECKO_EXPORT InputPin<MessageQuat>;

template class VRECKO_EXPORT OutputPin<MessageMatrix>;
template class VRECKO_EXPORT InputPin<MessageMatrix>;





// Macros for single-line definition
// DELARE_INPUT should be in the header file (.h)
#define DECLARE_INPUT(name, message_type) \
    osg::ref_ptr<vrecko::InputPin<message_type>> input##name; \
    void onMessage##name(message_type *message);

// INIT_INPUT should come in the .cpp file
#define INIT_INPUT_EXTNAME(name, message_type, yourClassName, extName) \
    addInputPin(input##name = new vrecko::InputPin<message_type>(this, extName, (vrecko::InputPin<message_type>::PROCESSING_METHOD)&yourClassName::onMessage##name));
    // TODO: In newer compilers, this _might_ be solvable without "yourClassname" AND also without "message_type"
    // by using something like
    //          (decltype(input##name)::PROCESSING_METHOD)&decltype(*this)::onMessage##name
    // It fails in VC2010, because decltype(*this) infers a class type of Class& and not Class as we need.
    // We need an rvalue reference for "this", but it doesn't seem to be supported as of yet (May 2011).
    // See this table:
    // http://blogs.msdn.com/b/vcblog/archive/2010/04/06/c-0x-core-language-features-in-vc10-the-table.aspx
    // Solution to exactly this problem is already in the working paper of C++0x (from March 2010)
    // http://en.wikipedia.org/wiki/Decltype (search for "decltype(v)::value_type" )
#define INIT_INPUT(name, message_type, yourClassName) \
    INIT_INPUT_EXTNAME(name, message_type, yourClassName, #name)

#define UNINIT_INPUT(name) \
    { \
        if (input##name) { \
            removeInputPin(input##name); \
            input##name = NULL; \
        } \
    }

#define METHOD_INPUT(name, message_type, yourClassName) \
    void yourClassName::onMessage##name(message_type *message)




#define DECLARE_OUTPUT(name, message_type) \
    osg::ref_ptr<vrecko::OutputPin<message_type>> output##name;

#define INIT_OUTPUT_EXTNAME(name, message_type, extName) \
    addOutputPin(output##name = new vrecko::OutputPin<message_type>(this, extName));

#define INIT_OUTPUT(name, message_type) INIT_OUTPUT_EXTNAME(name, message_type, #name)

#define UNINIT_OUTPUT(name) \
    { \
        if (output##name) { \
            removeOutputPin(output##name); \
            output##name = NULL; \
        } \
    }




#define DECLARE_REQUEST_INPUT(name, message_type, returning_message_type) \
    osg::ref_ptr<vrecko::RequestInputPin<message_type, returning_message_type>> reqInput##name; \
    osg::ref_ptr<returning_message_type> onRequest##name(message_type *message);

#define INIT_REQUEST_INPUT_EXTNAME(name, message_type, returning_message_type, yourClassName, extName) \
    addRequestInputPin(reqInput##name = new vrecko::RequestInputPin<message_type, returning_message_type>(this, extName, (vrecko::RequestInputPin<message_type, returning_message_type>::PROCESSING_METHOD)&yourClassName::onRequest##name));

#define INIT_REQUEST_INPUT(name, message_type, returning_message_type, yourClassName) \
    INIT_REQUEST_INPUT_EXTNAME(name, message_type, returning_message_type, yourClassName, #name)

#define UNINIT_REQUEST_INPUT(name) \
    { \
        if (reqInput##name) { \
            removeRequestInputPin(reqInput##name); \
            reqInput##name = NULL; \
        } \
    }

#define METHOD_REQUEST_INPUT(name, message_type, returning_message_type, yourClassName) \
    osg::ref_ptr<returning_message_type> yourClassName::onRequest##name(message_type *message)



#define DECLARE_REQUEST_OUTPUT(name, message_type, returning_message_type) \
    osg::ref_ptr<vrecko::RequestOutputPin<message_type, returning_message_type>> reqOutput##name;

#define INIT_REQUEST_OUTPUT_EXTNAME(name, message_type, returning_message_type, extName) \
    addRequestOutputPin(reqOutput##name = new vrecko::RequestOutputPin<message_type, returning_message_type>(this, extName));

#define INIT_REQUEST_OUTPUT(name, message_type, returning_message_type) \
    INIT_REQUEST_OUTPUT_EXTNAME(name, message_type, returning_message_type, #name)

#define UNINIT_REQUEST_OUTPUT(name) \
    { \
        if (reqOutput##name) { \
            removeRequestOutputPin(reqOutput##name); \
            reqOutput##name = NULL; \
        } \
    }


};

#endif