decl_node_map.hpp

#pragma once
 
#include <map>
#include <memory>
 
#include "../../global.hpp"
#include "../../string.hpp"
 
#include "../genapi.hpp"
 
#ifdef _MSC_VER
#  pragma warning(push, 1)
#  pragma warning(disable : 4244)
#endif
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  template <>
  inline HandleGuard<GenApi::NodeMap>::HandleGuard(void *handle) noexcept
      : HandleGuard<GenApi::NodeMap>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
  namespace GenApi
  {


    class NodeMap : public std::enable_shared_from_this<NodeMap>
    {
 
    public:
      using GuardType = HandleGuard<GenApi::NodeMap>;


      class GenApiVersion final
      {
      public:

        GenApiVersion() noexcept = default;


        GenApiVersion(std::uint16_t major, std::uint16_t minor, std::uint16_t subMinor) noexcept
            : major_(major)
            , minor_(minor)
            , subMinor_(subMinor)
        {
        }


        String ToString() const
        {
          StringStream stream;
          stream << major_ << "." << minor_ << "." << subMinor_;
          return stream.str();
        }


        std::uint16_t Major() const noexcept
        {
          return major_;
        }


        void SetMajor(std::uint16_t major) noexcept
        {
          major_ = major;
        }


        std::uint16_t Minor() const noexcept
        {
          return minor_;
        }


        void SetMinor(std::uint16_t minor) noexcept
        {
          minor_ = minor;
        }


        std::uint16_t SubMinor() const noexcept
        {
          return subMinor_;
        }


        void SetSubMinor(std::uint16_t subMinor) noexcept
        {
          subMinor_ = subMinor;
        }


        bool operator==(const GenApiVersion &version) const noexcept
        {
          return major_ == version.major_ && minor_ == version.minor_ && subMinor_ == version.subMinor_;
        }


        bool operator!=(const GenApiVersion &version) const noexcept
        {
          return !(*this == version);
        }


        bool operator<(const GenApiVersion &version) const noexcept
        {
          return (major_ < version.major_)    ? true
                 : (major_ != version.major_) ? false
                 : (minor_ < version.minor_)  ? true
                 : (minor_ != version.minor_) ? false
                                              : subMinor_ < version.subMinor_;
        }


        bool operator<=(const GenApiVersion &version) const noexcept
        {
          return (*this == version) || (*this < version);
        }


        bool operator>(const GenApiVersion &version) const noexcept
        {
          return (*this != version) && !(*this < version);
        }


        bool operator>=(const GenApiVersion &version) const noexcept
        {
          return !(*this < version);
        }
 
      private:
        std::uint16_t major_    = 0;
        std::uint16_t minor_    = 0;
        std::uint16_t subMinor_ = 0;
      };
 
      static NodeMapPtr Create(const Device &device, const String &name);


      static NodeMapPtr FromHandle(HandleGuard<NodeMap> &&guard, const String &name, const Device &device);
 
      template <class T>
      static NodeMapPtr FromHandle(HandleGuard<NodeMap> &&guard, const String &name, const Device &device)
      {
        return FromHandle(std::move(guard), name, device);
      }
 
      template <class T>
      static NodeMapPtr FromHandle(HandleGuard<NodeMap> &&guard)
      {
        return FromHandle(std::move(guard), String(), nullptr);
      }


      static NodeMapPtr FromHandle(HandleGuard<NodeMap> &&guard, const String &name, void *provider)
      {
        if (!guard.Handle())
          throw std::runtime_error("handle must not be null");
 
        return NodeMapPtr(new NodeMap(std::move(guard), name, provider));
      }
 
      template <class T>
      static NodeMapPtr FromHandle(HandleGuard<NodeMap> &&guard, const String &name, void *provider)
      {
        return FromHandle(std::move(guard), name, provider);
      }


      void *Handle() const noexcept
      {
        return handle_.Handle();
      }


      String Name() const
      {
        return name_;
      }


      String Description() const
      {
        ReadDescription();
        return description_;
      }


      String VendorName() const
      {
        return GetInfoAsString(NodeMapInfo::Vendor);
      }


      String ModelName() const
      {
        return GetInfoAsString(NodeMapInfo::Model);
      }


      String TransportLayerNamespace() const
      {
        return GetInfoAsString(NodeMapInfo::Namespace);
      }


      String ToolTip() const
      {
        return GetInfoAsString(NodeMapInfo::Tooltip);
      }


      GenApiVersion XmlFileVersion() const
      {
        return GenApiVersion(static_cast<std::uint16_t>(GetInfoAsInt(NodeMapInfo::DeviceVersionMajor)),
                             static_cast<std::uint16_t>(GetInfoAsInt(NodeMapInfo::DeviceVersionMinor)),
                             static_cast<std::uint16_t>(GetInfoAsInt(NodeMapInfo::DeviceVersionSubMinor)));
      }


      GenApiVersion XmlFileSchemaVersion() const
      {
        return GenApiVersion(static_cast<std::uint16_t>(GetInfoAsInt(NodeMapInfo::SchemaVersionMajor)),
                             static_cast<std::uint16_t>(GetInfoAsInt(NodeMapInfo::SchemaVersionMinor)),
                             static_cast<std::uint16_t>(GetInfoAsInt(NodeMapInfo::SchemaVersionSubMinor)));
      }


      void PollNodes()
      {
        auto lastPoll = lastPoll_;
        lastPoll_     = std::chrono::system_clock::now();
        auto delta    = lastPoll_ - lastPoll;
 
        NativeCall([&]() {
          return CExports::NMPollNodes(
              Handle(),
              static_cast<CExports::cvbval_t>(std::chrono::duration_cast<std::chrono::milliseconds>(delta).count()));
        });
      }


      void LoadSettings(const String &fileName)
      {
        NativeCall([&]() { return CExports::NMLoadSetTyped(Handle(), fileName.c_str(), nullptr, nullptr); });
      }


      void SaveSettings(const String &fileName) const
      {
        NativeCall([&]() { return CExports::NMSaveSetTyped(Handle(), fileName.c_str(), nullptr, nullptr); });
      }


      template <class RANGE>
      typename TypedRange<void, String, RANGE>::type SaveSettings(const String &fileName, const RANGE &range) const
      {
        NativeCall([&]() {
          return CExports::NMSaveSetExTyped(Handle(), fileName.c_str(), BuildNodeList(range).c_str(), nullptr, nullptr);
        });
      }


      template <class RANGE>
      typename TypedRange<void, NodePtr, RANGE>::type SaveSettings(const String &fileName, const RANGE &range) const
      {
        auto rangeAdapter = MakeRangeAdapter<NodePtr>(range);
        std::vector<String> names;
        names.reserve(rangeAdapter.Size());
        for (const auto &node : range)
          names.emplace_back(node->Name());
        SaveSettings(fileName, names);
      }


      template <class... NAMES>
      typename VarArgRange<void, const String &, NAMES...>::type SaveSettings(const String &fileName,
                                                                              const NAMES &...names) const
      {
        std::vector<String> range = {names...};
        SaveSettings(fileName, range);
      }


      template <class... NODES>
      typename VarArgRange<void, const Node &, NODES...>::type SaveSettings(const String &fileName,
                                                                            const NODES &...nodes) const
      {
        SaveSettings(fileName, nodes.Name()...);
      }


      std::vector<String> AvailableFiles() const;


      void DownloadFile(const String &fileName, const String &fileSelectorEntryName) const
      {
        NativeCall(
            [&]() { return CExports::NMDownloadFileTyped(Handle(), fileSelectorEntryName.c_str(), fileName.c_str()); });
      }


      std::vector<uint8_t> DownloadFile(const String &fileSelectorEntryName) const
      {
        size_t size = 0;
        NativeCall([&]() {
          return CExports::NMDownloadFileMemoryTyped(Handle(), fileSelectorEntryName.c_str(), nullptr, size);
        });
        std::vector<uint8_t> buffer(size);
        NativeCall([&]() {
          return CExports::NMDownloadFileMemoryTyped(Handle(), fileSelectorEntryName.c_str(), buffer.data(), size);
        });
        return buffer;
      }


      void UploadFile(const String &fileName, const String &fileSelectorEntryName)
      {
        NativeCall(
            [&]() { return CExports::NMUploadFileTyped(Handle(), fileSelectorEntryName.c_str(), fileName.c_str()); });
      }


      Cvb::String ToJson(std::function<void(NodePtr, const std::string &)> serializationErrorCallback = nullptr)
      {
        std::vector<NodePtr> nodes = {};
        auto nodesMap              = Nodes();
        for (auto &kvp : nodesMap)
        {
          nodes.push_back(kvp.second);
        }
 
        return ToJson(nodes, serializationErrorCallback);
      }


      Cvb::String ToJson(const std::vector<NodePtr> nodes,
                         std::function<void(NodePtr, const std::string &)> serializationErrorCallback = nullptr);


      template <class T>
      std::shared_ptr<T> Node(const String &name) const
      {
        static_assert(std::is_base_of<Cvb::GenApi::Node, T>::value, "requested node type must be derived from Node");
        auto ptr = std::dynamic_pointer_cast<T>(Node(name));
        if (!ptr)
          throw std::runtime_error("requested node can not be casted to the given type");
 
        return ptr;
      }


      NodePtr Node(const String &name) const;


      template <class T>
      std::shared_ptr<T> TryGetNode(const String &name) const noexcept
      {
        try
        {
          return Node<T>(name);
        }
        catch (...)
        {
          return nullptr;
        }
      }


      NodePtr TryGetNode(const String &name) const noexcept;


      std::map<String, NodePtr> Nodes() const;
 
    private:
      NodeMap(HandleGuard<NodeMap> &&guard, const String &name, void *provider);
 
      void ReadDescription() const;
 
      void FillNodeKeys() const;
 
      void NativeCall(std::function<CExports::cvbres_t()> fn) const
      {
        auto result = fn();
        if (result < 0)
        {
          auto message = Utilities::SystemInfo::GetLastErrorMessage();
          if (message.empty())
            message = "Error";
 
          std::stringstream stream;
          auto name = Name();
          std::string asciName(name.begin(), name.end());
          stream << "NodeMap[" << asciName << "]: " << message;
          std::rethrow_exception(CvbException::FromCvbResult(result, stream.str()));
        }
      }
 
      template <class T>
      T NativeCall(std::function<CExports::cvbres_t(T &value)> fn) const
      {
        T value;
        auto result = fn(value);
        if (result < 0)
        {
          auto message = Utilities::SystemInfo::GetLastErrorMessage();
          if (message.empty())
            message = "Error";
 
          std::stringstream stream;
          auto name = Name();
          std::string asciName(name.begin(), name.end());
          stream << "NodeMap[" << asciName << "]: " << message;
          std::rethrow_exception(CvbException::FromCvbResult(result, stream.str()));
        }
        return value;
      }
 
      std::int64_t GetInfoAsInt(NodeMapInfo command) const
      {
        return static_cast<std::int64_t>(NativeCall<CExports::cvbint64_t>([&](CExports::cvbint64_t &value) {
          return CExports::NMInfoAsInteger(Handle(), static_cast<CExports::TNodeMapInfo>(command), value);
        }));
      }
 
      String GetInfoAsString(NodeMapInfo command) const
      {
        return NativeCall<String>([&](String &value) {
          std::size_t bufferSize = 0;
          auto bufferSizeResult  = CExports::NMInfoAsStringTyped(Handle(), static_cast<CExports::TNodeMapInfo>(command),
                                                                 reinterpret_cast<Char *>(0), bufferSize);
          if (bufferSizeResult < 0)
            return bufferSizeResult;
 
          std::vector<Char> buffer(bufferSize);
          auto bufferResult = CExports::NMInfoAsStringTyped(Handle(), static_cast<CExports::TNodeMapInfo>(command),
                                                            reinterpret_cast<Char *>(&buffer[0]), bufferSize);
          if (bufferResult < 0)
            return bufferResult;
 
          value = String(reinterpret_cast<Char *>(&buffer[0]));
          return bufferResult;
        });
      }
 
      template <class RANGE>
      typename TypedRange<String, String, RANGE>::type BuildNodeList(const RANGE &range) const
      {
        StringStream nameStream;
        for (const auto &name : range)
          nameStream << name << CVB_LIT("|");
 
        return nameStream.str();
      }
 
      HandleGuard<NodeMap> handle_;
 
      String name_;
 
      mutable ReleaseObjectGuard provider_{nullptr};
 
      mutable String description_;
 
      mutable bool descriptionRead_ = false;
 
      mutable std::map<String, std::weak_ptr<class Node>> nodes_;
 
      mutable std::map<String, bool> nodeKeys_;
 
      mutable bool nodeKeysFilled_ = false;
 
      std::chrono::system_clock::time_point lastPoll_;
    };
 
  }  // namespace GenApi
 
  using GenApi::NodeMap;
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb
 
#ifdef _MSC_VER
#  pragma warning(pop)
#endif