devicefactory.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 "devicefactory.h"
 
#include <xstypes/xsdeviceid.h>
#include "xsdevice_def.h"
#include "communicator.h"
#include "devicetypes.h"
#include "mtixdevice.h"
#include "mtix0device.h"
#include "mtix00device.h"
#include "mtigdevice.h"
#include "mti7_mti8device.h"
#include "mti3x0device.h"
#include "mti6x0device.h"
#include "mti8x0device.h"
#include "dotdevice.h"
 
DeviceFactory::DeviceFactory()
{
}
 
bool DeviceFactory::registerMasterDeviceType(DeviceTypeId deviceTypeId, MasterConstructFunc constructFunc)
{
        bool rv = m_masterConstructors.insert(std::make_pair(deviceTypeId, constructFunc)).second;
        // it should be a master XOR a standalone (or neither)
        assert(m_standaloneConstructors.find(deviceTypeId) == m_standaloneConstructors.end());
        return rv;
}
 
bool DeviceFactory::registerStandaloneDeviceType(DeviceTypeId deviceTypeId, StandaloneConstructFunc constructFunc)
{
        m_standaloneConstructors[deviceTypeId] = constructFunc;
        // it should be a master XOR a standalone (or neither)
        assert(m_masterConstructors.find(deviceTypeId) == m_masterConstructors.end());
        return true;
}
 
XsDevice* DeviceFactory::constructDevice(DeviceTypeId deviceTypeId, Communicator* comm)
{
        XsDevice* device = nullptr;
        if (deviceTypeId != DeviceType::INVALID)
        {
                auto i = m_masterConstructors.find(deviceTypeId);
                if (i != m_masterConstructors.end())
                {
                        device = (i->second)(*this, comm);
                        device->addRef();
                }
                else
                {
                        auto j = m_standaloneConstructors.find(deviceTypeId);
                        if (j != m_standaloneConstructors.end())
                        {
                                device = (j->second)(comm);
                                device->addRef();
                        }
                }
        }
        return device;
}
 
XsDevice* DeviceFactory::createMasterDevice(Communicator* communicator, bool doInitialize)
{
        if (communicator != nullptr)
        {
                DeviceTypeId deviceTypeId = deviceToTypeId(communicator->masterDeviceId());
                XsDevice* constructedDevice = constructDevice(deviceTypeId, communicator);
 
                if (!doInitialize || initializeDevice(constructedDevice))
                {
#ifndef XSENS_DEBUG
                        // this is support debug info, we don't want to spam the debugger windows
                        JLWRITEG("Created master device with id: " << constructedDevice->deviceId() << " and firmware version: " << constructedDevice->firmwareVersion().toString());
#endif
                        return constructedDevice;
                }
 
                // construction failed
                if (constructedDevice)
                        constructedDevice->removeRef();
                else
                        communicator->destroy();
        }
        return nullptr;
}
 
DeviceFactory::DeviceTypeId DeviceFactory::deviceToTypeId(XsDeviceId const& deviceId) const
{
        if (deviceId.isMti() || deviceId.isMtig())
        {
                if (deviceId.isMtig())
                        return DeviceType::MTIG;
                if (deviceId.isMtiX00())
                        return DeviceType::MTI_X00;
                if (deviceId.isMtiX0())
                        return DeviceType::MTI_X0;
                if (deviceId.isMtiX() && deviceId.isGnss())
                        return DeviceType::MTI_7_MTI_8;//this is used for both the MTi-7 and MTi-8
                if (deviceId.isMtiX())
                        return DeviceType::MTI_X;
                if (deviceId.isMti3X0())
                        return DeviceType::MTI_3X0;
                if (deviceId.isMti6X0())
                        return DeviceType::MTI_6X0;
                if (deviceId.isMti8X0())
                        return DeviceType::MTI_8X0;
                if (deviceId.isDot())
                        return DeviceType::DOT;
        }
 
        return DeviceType::INVALID;
}
 
void DeviceFactory::removeExistingDevice(const XsDeviceId& deviceId)
{
        (void) deviceId;
}
 
bool DeviceFactory::initializeDevice(XsDevice* dev) const
{
        if (dev && dev->initialize())
                return true;
        return false;
}
 
bool DeviceFactory::initializeDevice(XsDevice& device) const
{
        return device.isInitialized() ? true : initializeDevice(&device);
}
 
void DeviceFactory::registerDevices()
{
        (void)registerStandaloneDeviceType(DeviceType::MTI_X,                   &MtiXDevice::constructStandalone);
        (void)registerStandaloneDeviceType(DeviceType::MTI_X0,                  &MtiX0Device::constructStandalone);
        (void)registerStandaloneDeviceType(DeviceType::MTI_X00,                 &MtiX00Device::constructStandalone);
        (void)registerStandaloneDeviceType(DeviceType::MTIG,                    &MtigDevice::constructStandalone);
        (void)registerStandaloneDeviceType(DeviceType::MTI_7_MTI_8,             &MTi7_MTi8Device::constructStandalone);
        (void)registerStandaloneDeviceType(DeviceType::MTI_3X0,                 &Mti3X0Device::constructStandalone);
        (void)registerStandaloneDeviceType(DeviceType::MTI_6X0,                 &Mti6X0Device::constructStandalone);
        (void)registerStandaloneDeviceType(DeviceType::MTI_8X0,                 &Mti8X0Device::constructStandalone);
        (void)registerStandaloneDeviceType(DeviceType::DOT,                     &DotDevice::constructStandalone);
}