discovery_information.hpp

#pragma once
 
#include "../global.hpp"
#include "../string.hpp"
 
#include "driver.hpp"
 
#include "../utilities/system_info.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace Driver
  {


    class DiscoveryInformation final
    {
      friend DeviceFactory;
 
    public:
      DiscoveryInformation(const DiscoveryInformation &other)            = delete;
      DiscoveryInformation &operator=(const DiscoveryInformation &other) = delete;
 
      DiscoveryInformation(DiscoveryInformation &&other) noexcept
          : DiscoveryInformation(other.list_, other.index_)
      {
      }
 
      ~DiscoveryInformation() = default;


      int Index() const noexcept
      {
        return index_;
      }
      int Index() const noexcept {…}


      void SetGenApiFeature(const String &nodeMapId, const String &featureName, const String &featureValue)
      {
        if (nodeMapId.empty())
          throw std::invalid_argument("node map ID must not be empty");
        if (featureName.empty())
          throw std::invalid_argument("feature name must not be empty");
        if (featureValue.empty())
          throw std::invalid_argument("feature value must not be empty");
 
        auto result = CExports::DOSetFeatureTyped(list_.get(), static_cast<size_t>(index_), nodeMapId.c_str(),
                                                  featureName.c_str(), featureValue.c_str());
        if (result < 0)
          std::rethrow_exception(CvbException::FromCvbResult(result, "failed to set device object feature"));
      }
      void SetGenApiFeature(const String &nodeMapId, const String &featureName, const String &featureValue) {…}


      void SetParameter(const String &name, const String &value)
      {
        if (name.empty())
          throw std::invalid_argument("name must not be empty");
        if (value.empty())
          throw std::invalid_argument("value must not be empty");
 
        auto result =
            CExports::DOSetParameterTyped(list_.get(), static_cast<size_t>(index_), name.c_str(), value.c_str());
        if (result < 0)
          std::rethrow_exception(CvbException::FromCvbResult(result, "failed to set device object parameter"));
      }
      void SetParameter(const String &name, const String &value) {…}


      String AccessToken() const
      {
        return (*this)[static_cast<DiscoveryProperties>(1000)];
      }
      String AccessToken() const {…}


      ModuleLayer DiscoveryLayer() const noexcept
      {
        try
        {
          return static_cast<ModuleLayer>(std::stoi((*this)[static_cast<DiscoveryProperties>(1001)]));
        }
        catch (...)
        {
          return ModuleLayer::Unknown;
        }
      }
      ModuleLayer DiscoveryLayer() const noexcept {…}


      bool TryGetProperty(DiscoveryProperties id, String &property) const noexcept
      {
        return (!InternalTryGetProperty(id, property)) ? true : false;
      }
      bool TryGetProperty(DiscoveryProperties id, String &property) const noexcept {…}


      String operator[](DiscoveryProperties id) const
      {
        String property;
        auto error = InternalTryGetProperty(id, property);
        if (error)
          std::rethrow_exception(error);
        return property;
      }
      String operator[](DiscoveryProperties id) const {…}


      DiscoveryInformation &operator=(DiscoveryInformation &&other) = default;
 
    private:
      typedef std::shared_ptr<void> List;
 
      DiscoveryInformation(List list, int index) noexcept
          : list_(list)
          , index_(index)
      {
      }
 
      std::exception_ptr InternalTryGetProperty(DiscoveryProperties id, String &property) const noexcept
      {
 
        std::size_t bufferSize = 0;
        auto bufferSizeResult =
            CExports::DOEntryGetInfoTyped(list_.get(), index_, static_cast<CExports::DODiscoverInfoCommands>(id),
                                          reinterpret_cast<Char *>(0), bufferSize);
        if (bufferSizeResult < 0)
          return CvbException::FromCvbResult(bufferSizeResult, "failed to get device object info (buffer size)");
        if (bufferSize < 2)
        {
          property.clear();
          return std::exception_ptr();
        }
 
        std::vector<std::uint8_t> buffer(bufferSize);
        auto entryResult =
            CExports::DOEntryGetInfoTyped(list_.get(), index_, static_cast<CExports::DODiscoverInfoCommands>(id),
                                          reinterpret_cast<Char *>(&buffer[0]), bufferSize);
        if (entryResult < 0)
          return CvbException::FromCvbResult(entryResult, "failed to get device object info");
 
        property = String(reinterpret_cast<Char *>(&buffer[0]));
        return std::exception_ptr();
      }
 
      List list_;
      int index_;
    };
    class DiscoveryInformation final {…};
 
  }  // namespace Driver
 
  using Driver::DiscoveryInformation;
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb