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(DiscoveryInformation && other) noexcept
      : DiscoveryInformation(other.list_, other.index_)
    {
    }


    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

}