peak_device_manager.hpp

Go to the documentation of this file.

#pragma once

#include <peak/common/peak_timeout.hpp>
#include <peak/device/peak_device.hpp>
#include <peak/device/peak_device_descriptor.hpp>
#include <peak/environment/peak_environment_inspector.hpp>
#include <peak/exception/peak_exception.hpp>
#include <peak/generic/peak_t_callback_manager.hpp>
#include <peak/interface/peak_interface.hpp>
#include <peak/interface/peak_interface_descriptor.hpp>
#include <peak/producer_library/peak_producer_library.hpp>
#include <peak/system/peak_system.hpp>
#include <peak/system/peak_system_descriptor.hpp>

#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <atomic>
#include <exception>
#include <functional>
#include <future>
#include <iterator>
#include <memory>
#include <mutex>
#include <utility>
#include <vector>
#include <cstdlib>
#include <new>

namespace peak
{

class DeviceManager final
{
public:
    enum class UpdatePolicy
    {
        ScanEnvironmentForProducerLibraries,
        DontScanEnvironmentForProducerLibraries
    };
    enum class ResetPolicy
    {
        ErrorOnOpenDevices,
        IgnoreOpenDevices
    };

    using SystemFoundCallback = std::function<void(const std::shared_ptr<const core::System>& foundSystem)>;
    using SystemFoundCallbackHandle = SystemFoundCallback*;
    using InterfaceFoundCallback = std::function<void(const std::shared_ptr<const core::Interface>& foundInterface)>;
    using InterfaceFoundCallbackHandle = InterfaceFoundCallback*;
    using InterfaceLostCallback = std::function<void(const std::string& lostInterfaceKey)>;
    using InterfaceLostCallbackHandle = InterfaceLostCallback*;
    using DeviceFoundCallback = std::function<void(const std::shared_ptr<core::DeviceDescriptor>& foundDevice)>;
    using DeviceFoundCallbackHandle = DeviceFoundCallback*;
    using DeviceLostCallback = std::function<void(const std::string& lostDeviceKey)>;
    using DeviceLostCallbackHandle = DeviceLostCallback*;
    using UpdateErrorCallback = std::function<void(const std::string& errorDescription)>;

    static DeviceManager& Instance();

    void AddProducerLibrary(const std::string& ctiPath);

    void Update(UpdatePolicy updatePolicy = UpdatePolicy::ScanEnvironmentForProducerLibraries,
        const UpdateErrorCallback& errorCallback = UpdateErrorCallback());
    void Reset(ResetPolicy resetPolicy = ResetPolicy::ErrorOnOpenDevices);
    core::Timeout InterfaceUpdateTimeout() const;
    void SetInterfaceUpdateTimeout(core::Timeout timeout_ms);
    core::Timeout DeviceUpdateTimeout() const;
    void SetDeviceUpdateTimeout(core::Timeout timeout_ms);

    std::vector<std::shared_ptr<const core::System>> Systems() const;
    std::vector<std::shared_ptr<const core::Interface>> Interfaces() const;
    std::vector<std::shared_ptr<core::DeviceDescriptor>> Devices() const;

    SystemFoundCallbackHandle RegisterSystemFoundCallback(const SystemFoundCallback& callback);
    void UnregisterSystemFoundCallback(SystemFoundCallbackHandle callbackHandle);
    InterfaceFoundCallbackHandle RegisterInterfaceFoundCallback(const InterfaceFoundCallback& callback);
    void UnregisterInterfaceFoundCallback(InterfaceFoundCallbackHandle callbackHandle);
    InterfaceLostCallbackHandle RegisterInterfaceLostCallback(const InterfaceLostCallback& callback);
    void UnregisterInterfaceLostCallback(InterfaceLostCallbackHandle callbackHandle);
    DeviceFoundCallbackHandle RegisterDeviceFoundCallback(const DeviceFoundCallback& callback);
    void UnregisterDeviceFoundCallback(DeviceFoundCallbackHandle callbackHandle);
    DeviceLostCallbackHandle RegisterDeviceLostCallback(const DeviceLostCallback& callback);
    void UnregisterDeviceLostCallback(DeviceLostCallbackHandle callbackHandle);

private:
    friend class Library;

    DeviceManager() = default;
    ~DeviceManager();

    DeviceManager(const DeviceManager& other) = delete;
    DeviceManager& operator=(const DeviceManager& other) = delete;

    void GetLostDevicesFromLostInterfaces(
        const std::unordered_set<std::string>& lostInterfaces, std::vector<std::string>& lostDevices);

    void TriggerSystemFoundCallbacks(const std::shared_ptr<const core::System>& foundSystem) const;
    void TriggerInterfaceFoundCallbacks(const std::shared_ptr<const core::Interface>& foundInterface) const;
    void TriggerInterfaceLostCallbacks(const std::string& lostInterfaceKey) const;
    void TriggerDeviceFoundCallbacks(const std::shared_ptr<core::DeviceDescriptor>& foundDevice) const;
    void TriggerDeviceLostCallbacks(const std::string& lostDeviceKey) const;

    void CheckDevicesOpened() const;

    std::mutex m_updateMutex;
    std::atomic<core::Timeout> m_interfaceUpdateTimeout_ms{ 100 };
    std::atomic<core::Timeout> m_deviceUpdateTimeout_ms{ 300 };

    std::vector<std::string> m_producerLibrariesToAdd;

    std::unordered_map<std::string, std::shared_ptr<core::ProducerLibrary>> m_producerLibraries;
    std::vector<std::shared_ptr<const core::System>> m_systems;
    std::vector<std::shared_ptr<const core::Interface>> m_interfaces;
    std::vector<std::shared_ptr<core::DeviceDescriptor>> m_devices;

    struct OpenedDevice
    {
        std::weak_ptr<core::Device> device;
        std::string displayName;
    };
    std::vector<OpenedDevice> m_openedDevices;

    core::TTriggerCallbackManager<SystemFoundCallbackHandle, SystemFoundCallback> m_systemFoundCallbackManager;
    core::TTriggerCallbackManager<InterfaceFoundCallbackHandle, InterfaceFoundCallback> m_interfaceFoundCallbackManager;
    core::TTriggerCallbackManager<InterfaceLostCallbackHandle, InterfaceLostCallback> m_interfaceLostCallbackManager;
    core::TTriggerCallbackManager<DeviceFoundCallbackHandle, DeviceFoundCallback> m_deviceFoundCallbackManager;
    core::TTriggerCallbackManager<DeviceLostCallbackHandle, DeviceLostCallback> m_deviceLostCallbackManager;

    std::mutex m_producerLibrariesToAddMutex;
    mutable std::mutex m_systemsMutex;
    mutable std::recursive_mutex m_interfacesMutex;
    mutable std::recursive_mutex m_devicesMutex;
    mutable std::mutex m_openedDevicesMutex;

#ifndef _MSC_VER
    template <typename T,
        typename std::enable_if<(noexcept(std::declval<T>()())
                                    || (std::is_pointer<typename std::decay<T>::type>::value && __cplusplus < 201703L)
                                    // NOTE pre c++17 there is no way to check weather a function pointer is noexcept
                                    )
                && std::is_same<void, decltype(std::declval<T>()())>::value && std::is_move_constructible<T>::value
                && std::is_nothrow_move_constructible<T>::value,
            int>::type = 0>
#else
    template <typename T>
#endif
    class RAIIGuard
    {
        T m_fun;

    public:
        RAIIGuard(T&& fun) noexcept
            : m_fun(std::forward<T>(fun))
        {}
        RAIIGuard(RAIIGuard const&) = delete;
        RAIIGuard(RAIIGuard&& other) noexcept
            : m_fun(std::move(other.m_fun))
        {}
        ~RAIIGuard() noexcept
        {
            m_fun();
        }
    };
    template <typename T>
    static RAIIGuard<T> makeRAIIGuard(T&& fun) noexcept
    {
        return { std::forward<T>(fun) };
    }

    template<typename T = DeviceManager>
    class LifetimeTracker
    {
        public:
            static void Create();
            static void Destroy();
            static T& Instance();

        private:
            static T* m_instance;
            static std::mutex m_mtx;
            static size_t m_initializedCount;
    };
};

} /* namespace peak */

/* Implementation */
namespace peak
{

template<typename T>
T* DeviceManager::LifetimeTracker<T>::m_instance = {};

template<typename T>
std::mutex DeviceManager::LifetimeTracker<T>::m_mtx = {};

template<typename T>
size_t DeviceManager::LifetimeTracker<T>::m_initializedCount = {};

template<typename T>
void DeviceManager::LifetimeTracker<T>::Create()
{
    std::lock_guard<decltype(m_mtx)> lock{m_mtx};

    if (!m_instance)
    {
        m_instance = new T{};
    }

    m_initializedCount++;
}

template<typename T>
void DeviceManager::LifetimeTracker<T>::Destroy()
{
    std::lock_guard<decltype(m_mtx)> lock{m_mtx};

    if (0 == m_initializedCount)
    {
        return;
    }

    m_initializedCount--;

    if (0 == m_initializedCount)
    {
        if (m_instance)
        {
            delete m_instance;
            m_instance = nullptr;
        }
    }
}

template<typename T>
T& DeviceManager::LifetimeTracker<T>::Instance()
{
    if (m_instance == nullptr)
    {
        throw core::NotInitializedException("Library is not initialized. Call peak::Library::Initalize() first!");
    }
    return *m_instance;
}

inline DeviceManager& DeviceManager::Instance()
{
    return DeviceManager::LifetimeTracker<>::Instance();
}

inline DeviceManager::~DeviceManager()
{
    Reset(ResetPolicy::IgnoreOpenDevices);
}

inline void DeviceManager::AddProducerLibrary(const std::string& ctiPath)
{
    std::lock_guard<std::mutex> lock(m_producerLibrariesToAddMutex);

    m_producerLibrariesToAdd.emplace_back(ctiPath);
}

inline void DeviceManager::Update(UpdatePolicy updatePolicy /*= UpdatePolicy::ScanEnvironmentForProducerLibraries*/,
    const UpdateErrorCallback& errorCallback /*= UpdateErrorCallback()*/)
{
    std::lock_guard<std::mutex> lockUpdate(m_updateMutex);

    std::vector<std::shared_ptr<core::System>> allFoundSystems;
    std::vector<std::shared_ptr<core::Interface>> allFoundInterfaces;
    std::vector<std::string> allLostInterfaces;
    std::vector<std::shared_ptr<core::DeviceDescriptor>> allFoundDevices;
    std::vector<std::string> allLostDevices;

    auto interfaceUpdateTimeout_ms = m_interfaceUpdateTimeout_ms.load();
    auto deviceUpdateTimeout_ms = m_deviceUpdateTimeout_ms.load();

    std::vector<std::string> ctiPaths;
    // We look for all producer libraries in the current environment if we have to
    if (updatePolicy == UpdatePolicy::ScanEnvironmentForProducerLibraries)
    {
        ctiPaths = core::EnvironmentInspector::CollectCTIPaths();
    }
    // We look for the manually added producer libraries
    {
        std::lock_guard<std::mutex> lock(m_producerLibrariesToAddMutex);

        ctiPaths.reserve(ctiPaths.size() + m_producerLibrariesToAdd.size());
        std::move(
            std::begin(m_producerLibrariesToAdd), std::end(m_producerLibrariesToAdd), std::back_inserter(ctiPaths));

        m_producerLibrariesToAdd.clear();
    }
    for (const auto& ctiPath : ctiPaths)
    {
        if (!m_producerLibraries.count(ctiPath))
        {
            try
            {
                auto producerLibrary = core::ProducerLibrary::Open(ctiPath);
                auto system = producerLibrary->System()->OpenSystem();

                m_producerLibraries.emplace(ctiPath, producerLibrary);
                allFoundSystems.emplace_back(system);
            }
            catch (const core::NotAvailableException&)
            {
                // TL not available or not supported.
                continue;
            }
            catch (const core::NotInitializedException&)
            {
                // TODO: check this on creation of DeviceManager?
                throw; // if this exception occurs, nothing else will work. so we stop here
            }
            catch (const core::Exception& ex)
            {
                if (errorCallback)
                {
                    try
                    {
                        errorCallback("[CTI - " + ctiPath + "]: " + ex.what());
                    }
                    catch (...)
                    {}
                }
            }
        }
    }

    auto interfaceUpdateFunc = [&interfaceUpdateTimeout_ms, &errorCallback](const std::shared_ptr<core::System>& system)
        -> std::tuple<std::vector<std::shared_ptr<core::Interface>>, std::vector<std::string>> {
        std::vector<std::shared_ptr<core::Interface>> foundInterfaces;
        std::vector<std::string> lostInterfaces;

        try
        {
            auto foundCallbackHandle = system->RegisterInterfaceFoundCallback(
                [&foundInterfaces](const std::shared_ptr<core::InterfaceDescriptor>& foundInterface) {
                    foundInterfaces.emplace_back(foundInterface->OpenInterface());
                });
            auto const foundCallbackCleanupGuard = makeRAIIGuard([system, &foundCallbackHandle]() noexcept {
                try
                {
                    system->UnregisterInterfaceFoundCallback(foundCallbackHandle);
                }
                catch (const core::Exception&)
                {
                    std::terminate();
                }
            });

            auto keysById = std::unordered_map<std::string, std::string>();
            for (const auto& iface : system->Interfaces())
            {
                keysById.emplace(iface->ID(), iface->Key());
            }
            auto lostCallbackHandle = system->RegisterInterfaceLostCallback(
                [&lostInterfaces, &keysById](const std::string& lostInterfaceId) {
                    auto idKeyPairIt = keysById.find(lostInterfaceId);

                    if (idKeyPairIt != keysById.end())
                    {
                        lostInterfaces.emplace_back((*idKeyPairIt).second);
                    }
                });
            auto const lostCallbackCleanupGuard = makeRAIIGuard([system, &lostCallbackHandle]() noexcept {
                try
                {
                    system->UnregisterInterfaceLostCallback(lostCallbackHandle);
                }
                catch (const core::Exception&)
                {
                    std::terminate();
                }
            });

            system->UpdateInterfaces(interfaceUpdateTimeout_ms);
        }
        catch (const core::Exception& ex)
        {
            if (errorCallback)
            {
                try
                {
                    errorCallback("[System - " + system->Key() + "]: " + ex.what());
                }
                catch (...)
                {}
            }
        }

        return std::make_tuple(foundInterfaces, lostInterfaces);
    };

    // We do an update on all available systems
    const std::launch launchPolicy =
        std::launch::async; // switching this to std::launch::deferred makes debugging easier
    std::vector<std::future<std::tuple<std::vector<std::shared_ptr<core::Interface>>, std::vector<std::string>>>>
        interfaceUpdateFutures;
    for (const auto& system : m_systems)
    {
        interfaceUpdateFutures.emplace_back(
            std::async(launchPolicy, interfaceUpdateFunc, std::const_pointer_cast<core::System>(system)));
    }
    for (const auto& system : allFoundSystems)
    {
        interfaceUpdateFutures.emplace_back(std::async(launchPolicy, interfaceUpdateFunc, system));
    }
    for (auto& future : interfaceUpdateFutures)
    {
        auto foundLostInterfacesTuple = future.get();
        auto foundInterfaces = std::get<0>(foundLostInterfacesTuple);
        auto lostInterfaces = std::get<1>(foundLostInterfacesTuple);
        allFoundInterfaces.reserve(allFoundInterfaces.size() + foundInterfaces.size());
        std::move(std::begin(foundInterfaces), std::end(foundInterfaces), std::back_inserter(allFoundInterfaces));
        allLostInterfaces.reserve(allLostInterfaces.size() + lostInterfaces.size());
        std::move(std::begin(lostInterfaces), std::end(lostInterfaces), std::back_inserter(allLostInterfaces));
    }

    auto deviceUpdateFunc = [this, &deviceUpdateTimeout_ms, &errorCallback](
                                const std::shared_ptr<core::Interface>& iface)
        -> std::tuple<std::vector<std::shared_ptr<core::DeviceDescriptor>>, std::vector<std::string>> {
        std::vector<std::shared_ptr<core::DeviceDescriptor>> foundDevices;
        std::vector<std::string> lostDevices;

        try
        {
            auto foundCallbackHandle = iface->RegisterDeviceFoundCallback(
                [this, &foundDevices](const std::shared_ptr<core::DeviceDescriptor>& foundDevice) {
                    foundDevice->RegisterDeviceOpenedCallback(
                        [this](const std::shared_ptr<core::Device>& openedDevice) {
                            std::lock_guard<std::mutex> lock(m_openedDevicesMutex);

                            // clear out closed devices
                            m_openedDevices.erase(std::remove_if(std::begin(m_openedDevices), std::end(m_openedDevices),
                                                      [](const OpenedDevice& dev) { return dev.device.expired(); }),
                                std::end(m_openedDevices));

                            // add the new one
                            OpenedDevice device;
                            device.device = openedDevice;
                            device.displayName = openedDevice->DisplayName();
                            m_openedDevices.push_back(device);
                        });

                    foundDevices.emplace_back(foundDevice);
                });
            auto const foundCallbackCleanupGuard = makeRAIIGuard([iface, &foundCallbackHandle]() noexcept {
                try
                {
                    iface->UnregisterDeviceFoundCallback(foundCallbackHandle);
                }
                catch (const core::Exception&)
                {
                    std::terminate();
                }
            });

            auto keysById = std::unordered_map<std::string, std::string>();
            for (const auto& device : iface->Devices())
            {
                keysById.emplace(device->ID(), device->Key());
            }
            auto lostCallbackHandle = iface->RegisterDeviceLostCallback(
                [&lostDevices, &keysById](const std::string& lostDeviceId) {
                    auto idKeyPairIt = keysById.find(lostDeviceId);

                    if (idKeyPairIt != keysById.end())
                    {
                        lostDevices.emplace_back((*idKeyPairIt).second);
                    }
                });
            auto const lostCallbackCleanupGuard = makeRAIIGuard([iface, &lostCallbackHandle]() noexcept {
                try
                {
                    iface->UnregisterDeviceLostCallback(lostCallbackHandle);
                }
                catch (const core::Exception&)
                {
                    std::terminate();
                }
            });

            iface->UpdateDevices(deviceUpdateTimeout_ms);
        }
        catch (const core::Exception& ex)
        {
            if (errorCallback)
            {
                try
                {
                    errorCallback("[Interface - " + iface->Key() + "]: " + ex.what());
                }
                catch (...)
                {}
            }
        }

        return std::make_tuple(foundDevices, lostDevices);
    };

    // We do an update on all available interfaces
    std::vector<std::future<std::tuple<std::vector<std::shared_ptr<core::DeviceDescriptor>>, std::vector<std::string>>>>
        deviceUpdateFutures;
    for (const auto& iface : m_interfaces)
    {
        deviceUpdateFutures.emplace_back(
            std::async(launchPolicy, deviceUpdateFunc, std::const_pointer_cast<core::Interface>(iface)));
    }
    for (const auto& iface : allFoundInterfaces)
    {
        deviceUpdateFutures.emplace_back(std::async(launchPolicy, deviceUpdateFunc, iface));
    }
    for (auto& future : deviceUpdateFutures)
    {
        auto foundLostDevicesTuple = future.get();
        auto foundDevices = std::get<0>(foundLostDevicesTuple);
        auto lostDevices = std::get<1>(foundLostDevicesTuple);
        allFoundDevices.reserve(allFoundDevices.size() + foundDevices.size());
        std::move(std::begin(foundDevices), std::end(foundDevices), std::back_inserter(allFoundDevices));
        allLostDevices.reserve(allLostDevices.size() + lostDevices.size());
        std::move(std::begin(lostDevices), std::end(lostDevices), std::back_inserter(allLostDevices));
    }

    // We apply the update changes to our internal lists
    {
        std::lock_guard<std::mutex> lock(m_systemsMutex);
        std::lock_guard<std::recursive_mutex> lock2(m_interfacesMutex);
        std::lock_guard<std::recursive_mutex> lock3(m_devicesMutex);

        m_systems.reserve(m_systems.size() + allFoundSystems.size());
        std::copy(std::begin(allFoundSystems), std::end(allFoundSystems), std::back_inserter(m_systems));

        for (const auto& lostInterfaceKey : allLostInterfaces)
        {
            m_interfaces.erase(std::find_if(std::begin(m_interfaces), std::end(m_interfaces),
                [&lostInterfaceKey](const std::shared_ptr<const core::Interface>& interfaceToCheck) -> bool {
                    return interfaceToCheck->Key() == lostInterfaceKey;
                }));
        }
        m_interfaces.reserve(m_interfaces.size() + allFoundInterfaces.size());
        std::copy(std::begin(allFoundInterfaces), std::end(allFoundInterfaces), std::back_inserter(m_interfaces));

        for (const auto& lostDeviceKey : allLostDevices)
        {
            m_devices.erase(std::find_if(std::begin(m_devices), std::end(m_devices),
                [&lostDeviceKey](const std::shared_ptr<core::DeviceDescriptor>& deviceToCheck) -> bool {
                    return deviceToCheck->Key() == lostDeviceKey;
                }));
        }
        m_devices.reserve(m_devices.size() + allFoundDevices.size());
        std::copy(std::begin(allFoundDevices), std::end(allFoundDevices), std::back_inserter(m_devices));
    }

    // We trigger all callbacks
    for (const auto& foundSystem : allFoundSystems)
    {
        TriggerSystemFoundCallbacks(foundSystem);
    }

    for (const auto& foundInterface : allFoundInterfaces)
    {
        TriggerInterfaceFoundCallbacks(foundInterface);
    }
    std::unordered_set<std::string> allLostInterfacesLookUp;
    for (const auto& lostInterfaceKey : allLostInterfaces)
    {
        TriggerInterfaceLostCallbacks(lostInterfaceKey);
        allLostInterfacesLookUp.emplace(lostInterfaceKey);
    }

    for (const auto& foundDevice : allFoundDevices)
    {
        TriggerDeviceFoundCallbacks(foundDevice);
    }
    GetLostDevicesFromLostInterfaces(allLostInterfacesLookUp, allLostDevices);
    for (const auto& lostDeviceKey : allLostDevices)
    {
        TriggerDeviceLostCallbacks(lostDeviceKey);
    }
}

inline void DeviceManager::Reset(ResetPolicy resetPolicy)
{
    std::lock_guard<std::mutex> lockUpdate(m_updateMutex);

    if (resetPolicy == ResetPolicy::ErrorOnOpenDevices)
    {
        // check if any devices are running
        CheckDevicesOpened();
    }

    {
        std::lock_guard<std::mutex> lock(m_systemsMutex);
        std::lock_guard<std::recursive_mutex> lock2(m_interfacesMutex);
        std::lock_guard<std::recursive_mutex> lock3(m_devicesMutex);

        {
            auto origDevices = m_devices;
            m_devices.clear();
            for (const auto& lostDevice : origDevices)
            {
                TriggerDeviceLostCallbacks(lostDevice->Key());
            }
        }

        {
            auto origInterfaces = m_interfaces;
            m_interfaces.clear();
            for (const auto& lostInterface : origInterfaces)
            {
                TriggerInterfaceLostCallbacks(lostInterface->Key());
            }
        }
        
        m_systems.clear();
        m_producerLibraries.clear();
    }

    {
        std::lock_guard<std::mutex> lock(m_producerLibrariesToAddMutex);
        m_producerLibrariesToAdd.clear();
    }
}

inline void DeviceManager::CheckDevicesOpened() const
{
    size_t openDevicesFound = 0;
    std::string deviceDisplayNames;

    {
        std::lock_guard<std::mutex> lock(m_openedDevicesMutex);

        for (const auto& openedDevice : m_openedDevices)
        {
            auto openDevice = openedDevice.device.lock();
            if (openDevice)
            {
                ++openDevicesFound;
                deviceDisplayNames += openedDevice.displayName;
                deviceDisplayNames += " ";
            }
        }
    }

    if (openDevicesFound > 0)
    {
        throw core::InternalErrorException(
            "Can't reset the device manager while there are devices open. The following devices ("
            + std::to_string(openDevicesFound) + ") are open: " + deviceDisplayNames);
    }
}

inline core::Timeout DeviceManager::InterfaceUpdateTimeout() const
{
    return m_interfaceUpdateTimeout_ms;
}

inline void DeviceManager::SetInterfaceUpdateTimeout(core::Timeout timeout_ms)
{
    m_interfaceUpdateTimeout_ms = timeout_ms;
}

inline core::Timeout DeviceManager::DeviceUpdateTimeout() const
{
    return m_deviceUpdateTimeout_ms;
}

inline void DeviceManager::SetDeviceUpdateTimeout(core::Timeout timeout_ms)
{
    m_deviceUpdateTimeout_ms = timeout_ms;
}

inline std::vector<std::shared_ptr<const core::System>> DeviceManager::Systems() const
{
    std::lock_guard<std::mutex> lock(m_systemsMutex);

    return m_systems;
}

inline std::vector<std::shared_ptr<const core::Interface>> DeviceManager::Interfaces() const
{
    std::lock_guard<std::recursive_mutex> lock(m_interfacesMutex);

    return m_interfaces;
}

inline std::vector<std::shared_ptr<core::DeviceDescriptor>> DeviceManager::Devices() const
{
    std::lock_guard<std::recursive_mutex> lock(m_devicesMutex);

    return m_devices;
}

inline DeviceManager::SystemFoundCallbackHandle DeviceManager::RegisterSystemFoundCallback(
    const DeviceManager::SystemFoundCallback& callback)
{
    return m_systemFoundCallbackManager.RegisterCallback(callback);
}

inline void DeviceManager::UnregisterSystemFoundCallback(DeviceManager::SystemFoundCallbackHandle callbackHandle)
{
    m_systemFoundCallbackManager.UnregisterCallback(callbackHandle);
}

inline DeviceManager::InterfaceFoundCallbackHandle DeviceManager::RegisterInterfaceFoundCallback(
    const DeviceManager::InterfaceFoundCallback& callback)
{
    return m_interfaceFoundCallbackManager.RegisterCallback(callback);
}

inline void DeviceManager::UnregisterInterfaceFoundCallback(DeviceManager::InterfaceFoundCallbackHandle callbackHandle)
{
    m_interfaceFoundCallbackManager.UnregisterCallback(callbackHandle);
}

inline DeviceManager::InterfaceLostCallbackHandle DeviceManager::RegisterInterfaceLostCallback(
    const DeviceManager::InterfaceLostCallback& callback)
{
    return m_interfaceLostCallbackManager.RegisterCallback(callback);
}

inline void DeviceManager::UnregisterInterfaceLostCallback(DeviceManager::InterfaceLostCallbackHandle callbackHandle)
{
    m_interfaceLostCallbackManager.UnregisterCallback(callbackHandle);
}

inline DeviceManager::DeviceFoundCallbackHandle DeviceManager::RegisterDeviceFoundCallback(
    const DeviceManager::DeviceFoundCallback& callback)
{
    return m_deviceFoundCallbackManager.RegisterCallback(callback);
}

inline void DeviceManager::UnregisterDeviceFoundCallback(DeviceManager::DeviceFoundCallbackHandle callbackHandle)
{
    m_deviceFoundCallbackManager.UnregisterCallback(callbackHandle);
}

inline DeviceManager::DeviceLostCallbackHandle DeviceManager::RegisterDeviceLostCallback(
    const DeviceManager::DeviceLostCallback& callback)
{
    return m_deviceLostCallbackManager.RegisterCallback(callback);
}

inline void DeviceManager::UnregisterDeviceLostCallback(DeviceManager::DeviceLostCallbackHandle callbackHandle)
{
    m_deviceLostCallbackManager.UnregisterCallback(callbackHandle);
}

inline void DeviceManager::GetLostDevicesFromLostInterfaces(
    const std::unordered_set<std::string>& lostInterfaces, std::vector<std::string>& lostDevices)
{
    std::lock_guard<std::recursive_mutex> lock(m_devicesMutex);

    for (const auto& device : m_devices)
    {
        if (lostInterfaces.count(device->ParentInterface()->Key()))
        {
            lostDevices.emplace_back(device->Key());
        }
    }
}

inline void DeviceManager::TriggerSystemFoundCallbacks(const std::shared_ptr<const core::System>& foundSystem) const
{
    m_systemFoundCallbackManager.TriggerCallbacks(foundSystem);
}

inline void DeviceManager::TriggerInterfaceFoundCallbacks(
    const std::shared_ptr<const core::Interface>& foundInterface) const
{
    m_interfaceFoundCallbackManager.TriggerCallbacks(foundInterface);
}

inline void DeviceManager::TriggerInterfaceLostCallbacks(const std::string& lostInterfaceKey) const
{
    m_interfaceLostCallbackManager.TriggerCallbacks(lostInterfaceKey);
}

inline void DeviceManager::TriggerDeviceFoundCallbacks(const std::shared_ptr<core::DeviceDescriptor>& foundDevice) const
{
    m_deviceFoundCallbackManager.TriggerCallbacks(foundDevice);
}

inline void DeviceManager::TriggerDeviceLostCallbacks(const std::string& lostDeviceKey) const
{
    m_deviceLostCallbackManager.TriggerCallbacks(lostDeviceKey);
}

} /* namespace peak */