EnumerationManager.h

Go to the documentation of this file.

// Copyright (c) 2025 Optris GmbH Co. KG

 
#pragma once
 
#include <vector>
#include <thread>
#include <mutex>
#include <memory>
#include <atomic>
#include <set>
#include <condition_variable>
#include <unordered_set>
#include <unordered_map>
 
#include "otcsdk/Api.h"
#include "otcsdk/common/DeviceInfo.h"
#include "otcsdk/enumeration/EnumerationClient.h"
#include "otcsdk/enumeration/EnumerationDetector.h"
 
 
namespace optris
{

class EnumerationManager
{
public:
  OTC_SDK_API EnumerationManager(const EnumerationManager&) = delete;
  OTC_SDK_API EnumerationManager& operator=(const EnumerationManager&) = delete;

  OTC_SDK_API EnumerationManager(EnumerationManager&&) = delete;
  OTC_SDK_API EnumerationManager& operator=(EnumerationManager&&) = delete;

  OTC_SDK_API virtual ~EnumerationManager();
 

  OTC_SDK_API static EnumerationManager& getInstance() noexcept;
   

  OTC_SDK_API std::vector<DeviceInfo> getDetectedDevices(int seconds = 0);
 

  OTC_SDK_API void addClient(EnumerationClient* client);

  OTC_SDK_API bool removeClient(EnumerationClient* client);
 
  
  OTC_SDK_API void run();

  OTC_SDK_API bool runAsync();

  OTC_SDK_API void stopRunning();

  OTC_SDK_API bool isRunning() const noexcept;
 

  OTC_SDK_API void setDetectionPeriod(int period) noexcept;

  OTC_SDK_API int getDetectionPeriod() const noexcept;
 

  OTC_SDK_API void registerDetector(const std::string& name, std::shared_ptr<EnumerationDetector> detector);

  OTC_SDK_API std::shared_ptr<EnumerationDetector> getDetector(const std::string& name);
  
 
private:
  using Mutex     = std::mutex;
  using Lock      = std::unique_lock<Mutex>;
  using Condition = std::condition_variable;
  
 
  EnumerationManager();
 
 
  void detectDevices();
 
  void notifyClientsOfDetection(const DeviceInfo& deviceInfo);
  void notifyClientsOfLostDetection(const DeviceInfo& deviceInfo);
 
  void waitForFirstPass(int seconds);
 
 
  Mutex                _detectedDevicesMutex;
  std::set<DeviceInfo> _detectedDevices;
 
  Mutex                        _runMutex;
  std::atomic<bool>            _shutdown;
  std::atomic<bool>            _running;
  std::atomic<int>             _period;
  std::unique_ptr<std::thread> _thread; 
 
  Mutex     _firstPassMutex;
  Condition _firstPassCondition;
  bool      _firstPassComplete;
 
  Mutex                                  _clientsMutex;
  std::unordered_set<EnumerationClient*> _clients;
 
  Mutex                                                                 _detectorsMutex;
  std::unordered_map<std::string, std::shared_ptr<EnumerationDetector>> _detectors;
};
 
 
// Inline implementations
inline void EnumerationManager::setDetectionPeriod(int period) noexcept
{
  _period = period;
}
 
inline int EnumerationManager::getDetectionPeriod() const noexcept
{
  return _period;
}
 
} // namespace optris