callbackmanagerxda.cpp

Go to the documentation of this file.

 
//  Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
//  All rights reserved.
//  
//  Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met:
//  
//  1.  Redistributions of source code must retain the above copyright notice,
//      this list of conditions, and the following disclaimer.
//  
//  2.  Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions, and the following disclaimer in the documentation
//      and/or other materials provided with the distribution.
//  
//  3.  Neither the names of the copyright holders nor the names of their contributors
//      may be used to endorse or promote products derived from this software without
//      specific prior written permission.
//  
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
//  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
//  THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
//  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS 
//  SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES 
//  OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE 
//  ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//  
 
 
//  Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
//  All rights reserved.
//  
//  Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met:
//  
//  1.  Redistributions of source code must retain the above copyright notice,
//      this list of conditions, and the following disclaimer.
//  
//  2.  Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions, and the following disclaimer in the documentation
//      and/or other materials provided with the distribution.
//  
//  3.  Neither the names of the copyright holders nor the names of their contributors
//      may be used to endorse or promote products derived from this software without
//      specific prior written permission.
//  
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
//  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
//  THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
//  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS 
//  SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES 
//  OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE 
//  ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//  
 
#include "callbackmanagerxda.h"
#include <xscommon/xsens_mutex.h>
 
using namespace xsens;
 
struct CallbackHandlerXdaItem
{
        XsCallbackPlainC* m_handler;    
        CallbackHandlerXdaItem* m_next; 
};
 
struct CallbackManagerItem
{
        CallbackManagerXda* m_manager;          
        CallbackManagerItem* m_next;    
};
 
CallbackManagerXda::CallbackManagerXda()
{
        m_callbackMutex = new MutexReadWrite;
        m_handlerList = NULL;
        m_managerList = NULL;
}
 
CallbackManagerXda::~CallbackManagerXda()
{
        try
        {
                clearChainedManagers();
                clearCallbackHandlers(false);
                delete m_callbackMutex;
        }
        catch (...)
        {
        }
}
 
void CallbackManagerXda::clearCallbackHandlers(bool chain)
{
        LockReadWrite locky(m_callbackMutex, LS_Write);
        CallbackHandlerXdaItem* currentHdlr = m_handlerList;
        while (currentHdlr)
        {
                CallbackHandlerXdaItem* next = currentHdlr->m_next;
                delete currentHdlr;
                currentHdlr = next;
        }
        m_handlerList = NULL;
 
        if (chain)
        {
                CallbackManagerItem* currentMgr = m_managerList;
                while (currentMgr)
                {
                        currentMgr->m_manager->clearCallbackHandlers(true);
                        currentMgr = currentMgr->m_next;
                }
        }
}
 
void CallbackManagerXda::addCallbackHandler(XsCallbackPlainC* cb, bool chain)
{
        if (!cb)
                return;
 
        LockReadWrite locky(m_callbackMutex, LS_Write);
 
        if (chain)
        {
                CallbackManagerItem* current = m_managerList;
                while (current)
                {
                        current->m_manager->addCallbackHandler(cb, true);
                        current = current->m_next;
                }
        }
 
        if (!m_handlerList)
        {
                CallbackHandlerXdaItem* current = new CallbackHandlerXdaItem;
                current->m_handler = cb;
                current->m_next = NULL;
                m_handlerList = current;
                return;
        }
 
        CallbackHandlerXdaItem* last;
        CallbackHandlerXdaItem* current = m_handlerList;
        while (current)
        {
                if (current->m_handler == cb)
                        return;
                last = current;
                current = current->m_next;
        }
 
        current = new CallbackHandlerXdaItem;
        current->m_handler = cb;
        current->m_next = NULL;
        last->m_next = current;
}
 
void CallbackManagerXda::removeCallbackHandler(XsCallbackPlainC* cb, bool chain)
{
        if (!cb)
                return;
 
        LockReadWrite locky(m_callbackMutex, LS_Write);
 
        if (chain)
        {
                CallbackManagerItem* current = m_managerList;
                while (current)
                {
                        current->m_manager->removeCallbackHandler(cb, true);
                        current = current->m_next;
                }
        }
 
        CallbackHandlerXdaItem* last = NULL;
        CallbackHandlerXdaItem* current = m_handlerList;
        while (current)
        {
                if (current->m_handler == cb)
                {
                        if (last)
                                last->m_next = current->m_next;
                        else
                                m_handlerList = current->m_next;
 
                        delete current;
                        return;
                }
                last = current;
                current = current->m_next;
        }
}
 
void CallbackManagerXda::clearChainedManagers()
{
        LockReadWrite locky(m_callbackMutex, LS_Write);
        CallbackManagerItem* current = m_managerList;
        while (current)
        {
                CallbackManagerItem* next = current->m_next;
                delete current;
                current = next;
        }
        m_managerList = NULL;
}
 
void CallbackManagerXda::addChainedManager(CallbackManagerXda* cm)
{
        if (!cm || cm == this)
                return;
 
        LockReadWrite locky(m_callbackMutex, LS_Write);
 
        if (!m_managerList)
        {
                CallbackManagerItem* current = new CallbackManagerItem;
                current->m_manager = cm;
                current->m_next = NULL;
                m_managerList = current;
                return;
        }
 
        CallbackManagerItem* last;
        CallbackManagerItem* current = m_managerList;
        while (current)
        {
                if (current->m_manager == cm)
                        return;
                last = current;
                current = current->m_next;
        }
 
        current = new CallbackManagerItem;
        current->m_manager = cm;
        current->m_next = NULL;
        last->m_next = current;
}
 
void CallbackManagerXda::removeChainedManager(CallbackManagerXda* cm)
{
        if (!cm)
                return;
 
        LockReadWrite locky(m_callbackMutex, LS_Write);
 
        CallbackManagerItem* last = NULL;
        CallbackManagerItem* current = m_managerList;
        while (current)
        {
                if (current->m_manager == cm)
                {
                        if (last)
                                last->m_next = current->m_next;
                        else
                                m_managerList = current->m_next;
 
                        delete current;
                        return;
                }
                last = current;
                current = current->m_next;
        }
}
 
void CallbackManagerXda::copyCallbackHandlersTo(CallbackManagerXda* cm, bool chain)
{
        cm->copyCallbackHandlersFrom(this, chain);
}
 
void CallbackManagerXda::copyCallbackHandlersFrom(CallbackManagerXda* cm, bool chain)
{
        LockReadWrite locky(m_callbackMutex, LS_Write);
        LockReadWrite locky2(cm->m_callbackMutex, LS_Read);
        CallbackHandlerXdaItem* current = cm->m_handlerList;
        while (current)
        {
                addCallbackHandler(current->m_handler, chain);
                current = current->m_next;
        }
}
 
void CallbackManagerXda::onDeviceStateChanged(XsDevice* dev, XsDeviceState newState, XsDeviceState oldState)
{
        LockReadWrite locky(m_callbackMutex, LS_Read);
        CallbackHandlerXdaItem* current = m_handlerList;
        while (current)
        {
                if (current->m_handler->m_onDeviceStateChanged)
                        current->m_handler->m_onDeviceStateChanged(current->m_handler, dev, newState, oldState);
                current = current->m_next;
        }
}
 
void CallbackManagerXda::onLiveDataAvailable(XsDevice* dev, const XsDataPacket* packet)
{
        LockReadWrite locky(m_callbackMutex, LS_Read);
        CallbackHandlerXdaItem* current = m_handlerList;
        while (current)
        {
                if (current->m_handler->m_onLiveDataAvailable)
                        current->m_handler->m_onLiveDataAvailable(current->m_handler, dev, packet);
                current = current->m_next;
        }
}
 
void CallbackManagerXda::onAllLiveDataAvailable(XsDevicePtrArray* devs, const XsDataPacketPtrArray* packets)
{
        LockReadWrite locky(m_callbackMutex, LS_Read);
        CallbackHandlerXdaItem* current = m_handlerList;
        while (current)
        {
                if (current->m_handler->m_onAllLiveDataAvailable)
                        current->m_handler->m_onAllLiveDataAvailable(current->m_handler, devs, packets);
                current = current->m_next;
        }
}
 
void CallbackManagerXda::onMissedPackets(XsDevice* dev, int count, int first, int last)
{
        LockReadWrite locky(m_callbackMutex, LS_Read);
        CallbackHandlerXdaItem* current = m_handlerList;
        while (current)
        {
                if (current->m_handler->m_onMissedPackets)
                        current->m_handler->m_onMissedPackets(current->m_handler, dev, count, first, last);
                current = current->m_next;
        }
}
 
void CallbackManagerXda::onDataUnavailable(XsDevice* dev, int64_t packetId)
{
        LockReadWrite locky(m_callbackMutex, LS_Read);
        CallbackHandlerXdaItem* current = m_handlerList;
        while (current)
        {
                if (current->m_handler->m_onDataUnavailable)
                        current->m_handler->m_onDataUnavailable(current->m_handler, dev, packetId);
                current = current->m_next;
        }
}
 
void CallbackManagerXda::onWakeupReceived(XsDevice* dev)
{
        LockReadWrite locky(m_callbackMutex, LS_Read);
        CallbackHandlerXdaItem* current = m_handlerList;
        while (current)
        {
                if (current->m_handler->m_onWakeupReceived)
                        current->m_handler->m_onWakeupReceived(current->m_handler, dev);
                current = current->m_next;
        }
}
 
void CallbackManagerXda::onProgressUpdated(XsDevice* dev, int curr, int total, const XsString* identifier)
{
        LockReadWrite locky(m_callbackMutex, LS_Read);
        CallbackHandlerXdaItem* current = m_handlerList;
        while (current)
        {
                if (current->m_handler->m_onProgressUpdated)
                        current->m_handler->m_onProgressUpdated(current->m_handler, dev, curr, total, identifier);
                current = current->m_next;
        }
}
 
int CallbackManagerXda::onWriteMessageToLogFile(XsDevice* dev, const XsMessage* message)
{
        LockReadWrite locky(m_callbackMutex, LS_Read);
        CallbackHandlerXdaItem* current = m_handlerList;
        bool rv = true;
        while (current)
        {
                if (current->m_handler->m_onWriteMessageToLogFile)
                        rv = current->m_handler->m_onWriteMessageToLogFile(current->m_handler, dev, message) && rv;
                current = current->m_next;
        }
        return rv ? 1 : 0;
}
 
void CallbackManagerXda::onBufferedDataAvailable(XsDevice* dev, const XsDataPacket* data)
{
        LockReadWrite locky(m_callbackMutex, LS_Read);
        CallbackHandlerXdaItem* current = m_handlerList;
        while (current)
        {
                if (current->m_handler->m_onBufferedDataAvailable)
                        current->m_handler->m_onBufferedDataAvailable(current->m_handler, dev, data);
                current = current->m_next;
        }
}
 
void CallbackManagerXda::onAllBufferedDataAvailable(XsDevicePtrArray* devs, const XsDataPacketPtrArray* packets)
{
        LockReadWrite locky(m_callbackMutex, LS_Read);
        CallbackHandlerXdaItem* current = m_handlerList;
        while (current)
        {
                if (current->m_handler->m_onAllBufferedDataAvailable)
                        current->m_handler->m_onAllBufferedDataAvailable(current->m_handler, devs, packets);
                current = current->m_next;
        }
}
 
void CallbackManagerXda::onConnectivityChanged(XsDevice* dev, XsConnectivityState newState)
{
        LockReadWrite locky(m_callbackMutex, LS_Read);
        CallbackHandlerXdaItem* current = m_handlerList;
        while (current)
        {
                if (current->m_handler->m_onConnectivityChanged)
                        current->m_handler->m_onConnectivityChanged(current->m_handler, dev, newState);
                current = current->m_next;
        }
}
 
void CallbackManagerXda::onInfoResponse(XsDevice* dev, XsInfoRequest request)
{
        LockReadWrite locky(m_callbackMutex, LS_Read);
        CallbackHandlerXdaItem* current = m_handlerList;
        while (current)
        {
                if (current->m_handler->m_onInfoResponse)
                        current->m_handler->m_onInfoResponse(current->m_handler, dev, request);
                current = current->m_next;
        }
}
 
void CallbackManagerXda::onError(XsDevice* dev, XsResultValue error)
{
        LockReadWrite locky(m_callbackMutex, LS_Read);
        CallbackHandlerXdaItem* current = m_handlerList;
        while (current)
        {
                if (current->m_handler->m_onError)
                        current->m_handler->m_onError(current->m_handler, dev, error);
                current = current->m_next;
        }
}
 
void CallbackManagerXda::onNonDataMessage(XsDevice* dev, XsMessage const* message)
{
        LockReadWrite locky(m_callbackMutex, LS_Read);
        CallbackHandlerXdaItem* current = m_handlerList;
        while (current)
        {
                if (current->m_handler->m_onNonDataMessage)
                        current->m_handler->m_onNonDataMessage(current->m_handler, dev, message);
                current = current->m_next;
        }
}
 
void CallbackManagerXda::onMessageDetected(XsDevice* dev, XsProtocolType type, XsByteArray const* rawMessage)
{
        LockReadWrite locky(m_callbackMutex, LS_Read);
        CallbackHandlerXdaItem* current = m_handlerList;
        while (current)
        {
                if (current->m_handler->m_onMessageDetected)
                        current->m_handler->m_onMessageDetected(current->m_handler, dev, type, rawMessage);
                current = current->m_next;
        }
}
 
void CallbackManagerXda::onMessageReceivedFromDevice(XsDevice* dev, XsMessage const* message)
{
        LockReadWrite locky(m_callbackMutex, LS_Read);
        CallbackHandlerXdaItem* current = m_handlerList;
        while (current)
        {
                if (current->m_handler->m_onMessageReceivedFromDevice)
                        current->m_handler->m_onMessageReceivedFromDevice(current->m_handler, dev, message);
                current = current->m_next;
        }
}
 
void CallbackManagerXda::onMessageSentToDevice(XsDevice* dev, XsMessage const* message)
{
        LockReadWrite locky(m_callbackMutex, LS_Read);
        CallbackHandlerXdaItem* current = m_handlerList;
        while (current)
        {
                if (current->m_handler->m_onMessageSentToDevice)
                        current->m_handler->m_onMessageSentToDevice(current->m_handler, dev, message);
                current = current->m_next;
        }
}
 
void CallbackManagerXda::onDataAvailable(XsDevice* dev, const XsDataPacket* packet)
{
        LockReadWrite locky(m_callbackMutex, LS_Read);
        CallbackHandlerXdaItem* current = m_handlerList;
        while (current)
        {
                if (current->m_handler->m_onDataAvailable)
                        current->m_handler->m_onDataAvailable(current->m_handler, dev, packet);
                current = current->m_next;
        }
}
 
void CallbackManagerXda::onAllDataAvailable(XsDevicePtrArray* devs, const XsDataPacketPtrArray* packets)
{
        LockReadWrite locky(m_callbackMutex, LS_Read);
        CallbackHandlerXdaItem* current = m_handlerList;
        while (current)
        {
                if (current->m_handler->m_onAllDataAvailable)
                        current->m_handler->m_onAllDataAvailable(current->m_handler, devs, packets);
                current = current->m_next;
        }
}
 
void CallbackManagerXda::onRecordedDataAvailable(XsDevice* dev, const XsDataPacket* packet)
{
        LockReadWrite locky(m_callbackMutex, LS_Read);
        CallbackHandlerXdaItem* current = m_handlerList;
        while (current)
        {
                if (current->m_handler->m_onRecordedDataAvailable)
                        current->m_handler->m_onRecordedDataAvailable(current->m_handler, dev, packet);
                current = current->m_next;
        }
}
 
void CallbackManagerXda::onAllRecordedDataAvailable(XsDevicePtrArray* devs, const XsDataPacketPtrArray* packets)
{
        LockReadWrite locky(m_callbackMutex, LS_Read);
        CallbackHandlerXdaItem* current = m_handlerList;
        while (current)
        {
                if (current->m_handler->m_onAllRecordedDataAvailable)
                        current->m_handler->m_onAllRecordedDataAvailable(current->m_handler, devs, packets);
                current = current->m_next;
        }
}
 
void CallbackManagerXda::onTransmissionRequest(int channelId, const XsByteArray* data)
{
        LockReadWrite locky(m_callbackMutex, LS_Read);
        CallbackHandlerXdaItem* current = m_handlerList;
        while (current)
        {
                if (current->m_handler->m_onTransmissionRequest)
                        current->m_handler->m_onTransmissionRequest(current->m_handler, channelId, data);
                current = current->m_next;
        }
}
 
void CallbackManagerXda::onRestoreCommunication(const XsString* portName, XsResultValue result)
{
        LockReadWrite locky(m_callbackMutex, LS_Read);
        CallbackHandlerXdaItem* current = m_handlerList;
        while (current)
        {
                if (current->m_handler->m_onRestoreCommunication)
                        current->m_handler->m_onRestoreCommunication(current->m_handler, portName, result);
                current = current->m_next;
        }
}