EnumerationManager.h

Go to the documentation of this file.

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

 
#pragma once
 
#include <atomic>
#include <vector>
#include <thread>
#include <mutex>
#include <memory>
#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();
   

  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:
  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 notifyClientsOfChangedDetection(const DeviceInfo& deviceInfo);
 
  void waitForDetectionUpdate(int seconds);
  void notifyOfDetectionUpdate();
 
 
  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     _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