EnumerationManager.h

Go to the documentation of this file.

// Copyright (c) 2008-2026 Optris GmbH & Co. KG

 
#pragma once
 
#include <atomic>
#include <vector>
#include <thread>
#include <mutex>
#include <memory>
#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:
  EnumerationManager(const EnumerationManager&) = delete;
  EnumerationManager& operator=(const EnumerationManager&) = delete;

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

  OTC_SDK_API ~EnumerationManager();
 

  OTC_SDK_API static EnumerationManager& getInstance();
   

  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 std::string addUsbDetector();

  OTC_SDK_API bool removeUsbDetector();

  OTC_SDK_API std::string addEthernetDetector(const std::string& networkAddress);

  OTC_SDK_API bool removeEthernetDetector(const std::string& networkAddress);

  OTC_SDK_API std::string addEthernetDetector(const IpAddress& networkAddress, int cidr);

  OTC_SDK_API bool removeEthernetDetector(const IpAddress& networkAddress, int cidr);

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

  OTC_SDK_API bool removeDetector(const std::string& name);

  OTC_SDK_API void clearDetectors();

  OTC_SDK_API std::vector<std::string> getDetectorNames();

  OTC_SDK_API std::shared_ptr<EnumerationDetector> getDetector(const std::string& name);
 
  
private:
  friend class DeviceClaimService;
 
 
  using Mutex      = std::mutex;
  using Lock       = std::unique_lock<Mutex>;
  using ScopedLock = std::scoped_lock<Mutex, Mutex>;
  using Condition  = std::condition_variable;
  
 
  EnumerationManager();
 
 
  void detectDevices();
  void debounceLostDetections(std::vector<DeviceInfo>& currentlyDetected);
 
  void runThread();
 
  void notifyClientsOfDetection(const DeviceInfo& deviceInfo);
  void notifyClientsOfLostDetection(const DeviceInfo& deviceInfo);
  void notifyClientsOfChangedDetection(const DeviceInfo& deviceInfo);
 
  void waitForDetectionUpdate(int seconds);
  void notifyOfDetectionUpdate();
 
  void setDeviceBusy(unsigned long serialNumber, const std::string& connectionInterface, bool busy);
 
 
  Mutex                   _detectedDevicesMutex;
  std::vector<DeviceInfo> _detectedDevices;

  Mutex _runMutex;

  std::unique_ptr<std::thread> _runThread;
  // Synchronizes when the run thread should start to the detection loop.
  Mutex             _runThreadMutex;
  Condition         _runThreadCondition;
  std::atomic<bool> _runThreadActive;

  std::atomic<bool> _running;
  std::atomic<bool> _actuallyRunning;
  std::atomic<int> _period;
    
 
  Mutex     _waitForDetectionUpdateMutex;
  Condition _waitForDetectionUpdateCondition;
  bool      _waitForDetectionUpdateComplete;
 
  Mutex _waitForDetectionUpdateConditionsMutex;
  bool  _newDetectorAdded;
 
  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