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_;
    }
 
 
    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 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"));
    }
 
 
    String AccessToken() const
    {
      return (*this)[static_cast<DiscoveryProperties>(1000)];
    }
 
 
    ModuleLayer DiscoveryLayer() const noexcept
    {
      try
      {
        return static_cast<ModuleLayer>(std::stoi((*this)[static_cast<DiscoveryProperties>(1001)]));
      }
      catch (...)
      {
        return ModuleLayer::Unknown;
      }
 
    }
 
 
 
 
    bool TryGetProperty(DiscoveryProperties id, String & property) const noexcept
    {
      return (!InternalTryGetProperty(id, property)) ? true : false;
    }
 
 
    String operator[](DiscoveryProperties id) const
    {
      String property;
      auto error = InternalTryGetProperty(id, property);
      if (error)
        std::rethrow_exception(error);
      return property;
    }
 
 
 
    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_;
};
 
}
 
using Driver::DiscoveryInformation;
 
CVB_END_INLINE_NS
 
}