DeviceInfo.h

Go to the documentation of this file.

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

 
#pragma once
 
#include <string>
#include <tuple>
 
#include "otcsdk/Api.h"
#include "otcsdk/common/DeviceType.h"
#include "otcsdk/communication/net/MacAddress.h"
#include "otcsdk/communication/net/IpAddress.h"
#include "otcsdk/communication/net/Port.h"
 
 
namespace optris
{

class DeviceInfo
{
public:
  OTC_SDK_API DeviceInfo() noexcept;
 

  OTC_SDK_API static DeviceType determineDeviceType(unsigned short hardwareRevision, unsigned short firmwareRevision) noexcept;
 

  OTC_SDK_API void setSerialNumber(unsigned long serialNumber) noexcept;

  OTC_SDK_API unsigned long getSerialNumber() const noexcept;

  OTC_SDK_API void setConnectionInterface(const std::string& connectionInterface) noexcept;

  OTC_SDK_API const std::string& getConnectionInterface() const noexcept;

  OTC_SDK_API void setConnectionInterfaceAddress(const std::string& address) noexcept;

  OTC_SDK_API const std::string& getConnectionInterfaceAddress() const noexcept;

  OTC_SDK_API void setIpAddress(const IpAddress& ipAddress) noexcept;

  OTC_SDK_API const IpAddress& getIpAddress() const noexcept;

  OTC_SDK_API void setTargetIpAddress(const IpAddress& ipAddress) noexcept;

  OTC_SDK_API const IpAddress& getTargetIpAddress() const noexcept;

  OTC_SDK_API void setPort(const Port& port) noexcept;

  OTC_SDK_API const Port& getPort() const noexcept;

  OTC_SDK_API DeviceType getDeviceType() const noexcept;

  OTC_SDK_API void setRevisions(unsigned short hardware, unsigned short firmware) noexcept;

  OTC_SDK_API unsigned short getHardwareRevision() const noexcept;

  OTC_SDK_API unsigned short getFirmwareRevision() const noexcept;

  OTC_SDK_API void setBusy(bool busy) noexcept;

  OTC_SDK_API bool isBusy() const noexcept;

  OTC_SDK_API void setMacAddress(const MacAddress& mac) noexcept;

  OTC_SDK_API const MacAddress& getMacAddress() const noexcept;
 

  bool operator==(const DeviceInfo& rhs) const noexcept;
  bool operator!=(const DeviceInfo& rhs) const noexcept;
  bool operator<(const DeviceInfo& rhs) const noexcept;
 
 
private:
  DeviceType  _deviceType;  
  std::string _connectionInterface;
  std::string _connectionInterfaceAddress;
 
 
  MacAddress _deviceMacAddress;
  IpAddress  _deviceIpAddress;
  IpAddress  _targetIpAddress;
  Port       _targetPort;
  
  unsigned long  _serialNumber;
  unsigned short _hardwareRevision;
  unsigned short _firmwareRevision;
  bool           _busy;
};
 
 
// Inline implementations
inline void DeviceInfo::setSerialNumber(unsigned long serialNumber) noexcept
{
  _serialNumber = serialNumber;
}
 
inline unsigned long DeviceInfo::getSerialNumber() const noexcept
{
  return _serialNumber;
}
 
inline const std::string& DeviceInfo::getConnectionInterface() const noexcept
{
  return _connectionInterface;
}
 
inline void DeviceInfo::setConnectionInterfaceAddress(const std::string& address) noexcept
{
  _connectionInterfaceAddress = address;
}
 
inline const std::string& DeviceInfo::getConnectionInterfaceAddress() const noexcept
{
  return _connectionInterfaceAddress;
}
 
inline void DeviceInfo::setIpAddress(const IpAddress& ipAddress) noexcept
{
  _deviceIpAddress = ipAddress;
}
 
inline const IpAddress& DeviceInfo::getIpAddress() const noexcept
{
  return _deviceIpAddress;
}
 
inline void DeviceInfo::setTargetIpAddress(const IpAddress& ipAddress) noexcept
{
  _targetIpAddress = ipAddress;
}
 
inline const IpAddress& DeviceInfo::getTargetIpAddress() const noexcept
{
  return _targetIpAddress;
}
 
inline void DeviceInfo::setPort(const Port& port) noexcept
{
  _targetPort = port;
}
 
inline const Port& DeviceInfo::getPort() const noexcept
{
  return _targetPort;
}
 
inline DeviceType DeviceInfo::getDeviceType() const noexcept
{
  return _deviceType;
}
 
inline unsigned short DeviceInfo::getHardwareRevision() const noexcept
{
  return _hardwareRevision;
}
 
inline unsigned short DeviceInfo::getFirmwareRevision() const noexcept
{
  return _firmwareRevision;
}
 
inline void DeviceInfo::setBusy(bool busy) noexcept
{
  _busy = busy;
}
 
inline bool DeviceInfo::isBusy() const noexcept
{
  return _busy;
}
 
inline void DeviceInfo::setMacAddress(const MacAddress& macAddress) noexcept
{
  _deviceMacAddress = macAddress;
}
 
inline const MacAddress& DeviceInfo::getMacAddress() const noexcept
{
  return _deviceMacAddress;
}
 
inline bool DeviceInfo::operator==(const DeviceInfo& rhs) const noexcept
{
  return (_deviceType                 == rhs._deviceType                 &&
          _connectionInterface        == rhs._connectionInterface        &&
          _connectionInterfaceAddress == rhs._connectionInterfaceAddress &&
          _deviceMacAddress           == rhs._deviceMacAddress           &&
          _deviceIpAddress            == rhs._deviceIpAddress            &&
          _targetIpAddress            == rhs._targetIpAddress            &&
          _targetPort                 == rhs._targetPort                 &&
          _serialNumber               == rhs._serialNumber               &&
          _hardwareRevision           == rhs._hardwareRevision           &&
          _firmwareRevision           == rhs._firmwareRevision           &&
          _busy                       == rhs._busy);
}
 
inline bool DeviceInfo::operator!=(const DeviceInfo& rhs) const noexcept
{
  return !operator==(rhs);
}
 
inline bool DeviceInfo::operator<(const DeviceInfo& rhs) const noexcept
{
  return std::tie(_serialNumber, _connectionInterface) < std::tie(rhs._serialNumber, rhs._connectionInterface);
}
 
} // namespace optris