AAX_CPacketDispatcher.h

Go to the documentation of this file.

/*================================================================================================*/
/*
 *
 *  Copyright 2013 by Avid Technology, Inc.
 *  All rights reserved.
 *  
 *  CONFIDENTIAL: This document contains confidential information.  Do not 
 *  read or examine this document unless you are an Avid Technology employee
 *  or have signed a non-disclosure agreement with Avid Technology which protects
 *  the confidentiality of this document.  DO NOT DISCLOSE ANY INFORMATION 
 *  CONTAINED IN THIS DOCUMENT TO ANY THIRD-PARTY WITHOUT THE PRIOR WRITTEN CONSENT 
 *  OF Avid Technolgy, INC.
 *
 */

/*================================================================================================*/


#ifndef AAX_CPACKETDISPATCHER_H
#define AAX_CPACKETDISPATCHER_H

#include "AAX.h"
#include "AAX_IController.h"
#include "AAX_CMutex.h"

#include <string>
#include <map>


class AAX_CPacket
{
public:
    AAX_CPacket(AAX_CFieldIndex iFieldIndex) : mID(iFieldIndex), mDirty(true), mDataSize(0) {}
    ~AAX_CPacket() {}
    
    template<typename DataType>
    DataType* GetPtr()
    {
        mDataSize = sizeof(DataType);
        void * data = mPacketData.Get(mDataSize);
        return reinterpret_cast<DataType*> (data);
    }
    
    void            SetDirty(bool iDirty)   { mDirty = iDirty; };
    bool            IsDirty() const         { return mDirty; };
    
    AAX_CFieldIndex GetID() const           { return mID; };
    uint32_t        GetSize() const         { return mDataSize; }
    
private:    
    AAX_CFieldIndex mID;
    bool            mDirty;
    uint32_t        mDataSize;

private:
    struct SPacketData
    {
    public:
        SPacketData();
        ~SPacketData();
        const void* Get() const;
        void* Get(size_t newSize) const;
    private:    
        mutable void*   mData;
    } mPacketData;
};

// GetPtr() specialization for void*
template <>
inline const void*
AAX_CPacket::GetPtr()
{
    return mPacketData.Get();
}


struct AAX_IPacketHandler
{
    virtual                     ~AAX_IPacketHandler() {};
    virtual AAX_IPacketHandler* Clone() const = 0;
    virtual AAX_Result          Call( AAX_CParamID iParamID, AAX_CPacket& ioPacket ) const = 0;
};

template<class TWorker>
class AAX_CPacketHandler : public AAX_IPacketHandler
{
    typedef AAX_Result(TWorker::*fPt2Fn)(AAX_CPacket&);
    typedef AAX_Result(TWorker::*fPt2FnEx)(AAX_CParamID, AAX_CPacket&);

public:
    AAX_CPacketHandler( TWorker* iPt2Object, fPt2Fn infPt )
        : pt2Object(iPt2Object), fpt(infPt), fptEx(NULL) {}
    
    AAX_CPacketHandler( TWorker* iPt2Object, fPt2FnEx infPt )
        : pt2Object(iPt2Object), fpt(NULL), fptEx(infPt) {}
    
    AAX_IPacketHandler* Clone() const
    {
        return new AAX_CPacketHandler(*this);
    }
    
    AAX_Result Call( AAX_CParamID iParamID, AAX_CPacket& ioPacket ) const
    {
        if (fptEx)
            return (*pt2Object.*fptEx)( iParamID, ioPacket);
        else if (fpt)
            return (*pt2Object.*fpt)( ioPacket);
        else
            return AAX_ERROR_NULL_OBJECT;
    }
    
protected:  
    TWorker *   pt2Object;  // pointer to object
    fPt2Fn      fpt ;       // pointer to member function
    fPt2FnEx    fptEx ;     // pointer to member function
};


class AAX_IEffectParameters;

class AAX_CPacketDispatcher
{
    typedef std::map<AAX_CFieldIndex, AAX_CPacket*> PacketsHolder;  
    typedef std::multimap<std::string, std::pair<AAX_CPacket*, AAX_IPacketHandler*> > PacketsHandlersMap;

public:
    AAX_CPacketDispatcher();
    ~AAX_CPacketDispatcher();
    
    void Initialize( AAX_IController* iPlugIn, AAX_IEffectParameters* iEffectParameters);
    
    AAX_Result RegisterPacket( AAX_CParamID paramID, AAX_CFieldIndex portID, const AAX_IPacketHandler* iHandler);
    
    template <class TWorker, typename Func>
    AAX_Result RegisterPacket( AAX_CParamID paramID, AAX_CFieldIndex portID,
                              TWorker* iPt2Object, Func infPt)
    {
        AAX_CPacketHandler<TWorker> handler(iPt2Object, infPt);
        return RegisterPacket(paramID, portID, &handler);
    }
    
    AAX_Result RegisterPacket( AAX_CParamID paramID, AAX_CFieldIndex portID)
    {
        AAX_CPacketHandler<AAX_CPacketDispatcher> handler(this, &AAX_CPacketDispatcher::GenerateSingleValuePacket);
        return RegisterPacket(paramID, portID, &handler);
    }
    
    AAX_Result SetDirty(AAX_CParamID paramID, bool iDirty = true);
    
    AAX_Result Dispatch();
    
    AAX_Result  GenerateSingleValuePacket( AAX_CParamID iParam, AAX_CPacket& ioPacket);
    
private:
    PacketsHolder           mPacketsHolder;
    PacketsHandlersMap      mPacketsHandlers;
    AAX_IController*        mController;
    AAX_IEffectParameters*  mEffectParameters;

    AAX_CMutex              mLockGuard;
};


#endif // AAX_CPACKETDISPATCHER_H