decl_node_map.hpp

#pragma once
#pragma once
 
#include <map>
#include <memory>
 
#include "../../global.hpp"
#include "../../genapi/node_map.hpp"
#include "../gevserver.hpp"
 
#include "../_decl/decl_node.hpp"
#include "../_decl/decl_server.hpp"
#include "../../genapi/_decl/decl_node_map.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace GevServer
  {

    class NodeMap : public std::enable_shared_from_this<NodeMap>
    {
    public:
      explicit NodeMap(const ServerPtr &server) noexcept;


      void *Handle() const noexcept
      {
        auto srv = server_.lock();
        if (!srv)
          return nullptr;
 
        return srv->Handle();
      }


      ServerPtr Server()
      {
        auto srv = server_.lock();
        if (!srv)
          return ServerPtr();
 
        return srv;
      }


      std::map<String, NodePtr> Nodes() const;

      void AddNode(const String &key, const NodePtr &value)
      {
        if (key.empty())
          throw std::runtime_error("key must not be empty");
        if (!value)
          throw std::runtime_error("node must not be null");
        if (value->NodeMap() != nullptr)
          if (!nodes_[key].owner_before(value) && !value.owner_before(nodes_[key]))
            return;  // has been added before
        auto name = value->NameOnly();
        if (key != name)
          throw std::runtime_error("key and value->NameOnly() must be equal");
 
        NativeCall([&]() { return CVB_CALL_CAPI(GSAddNode(Handle(), value->Handle())); });
 
        // add node map to item
        value->SetNodeMap(std::const_pointer_cast<NodeMap>(shared_from_this()));
 
        nodes_[key] = value;
      }

      void AddNode(const String &key, const NodePtr &value, const NodeList &kind);

      void AddNode(const NodePtr &value)
      {
        if (!value)
          throw std::runtime_error("node must not be null");
 
        AddNode(value->NameOnly(), value);
      }

      bool RemoveNode(const Node &node)
      {
        return RemoveNode(node.NameOnly());
      }

      bool RemoveNode(const String &key)
      {
        auto node = TryGetNode(key);
        if (node)
        {
          if (node == nullptr)
            throw std::runtime_error("node to remove must not be null");
          if (node->NodeMap() != shared_from_this())
            return false;
 
          auto it = nodes_.find(node->NameOnly());
          if (it != nodes_.end())
          {
            nodes_.erase(it);
            NativeCall([&]() { return CVB_CALL_CAPI(GSRemoveNode(Handle(), node->Handle())); });
            return true;
          }
        }
        return false;
      }

      bool IsReadOnly() const
      {
        auto srv = server_.lock();
        if (srv)
          return srv->State() != GevServer::State::Configuration;
        else
          throw std::runtime_error("this node map is not attached to a server");
      }

      String ModelName() const
      {
        auto modelName = Node(CVB_LIT("DeviceModelName"));
        return modelName != nullptr ? modelName->DisplayName() : CVB_LIT("CVGevServer");
      }

      String ModuleName() const noexcept
      {
        return CVB_LIT("Device");
      }

      String TransportLayerNamespace() const noexcept
      {
        return CVB_LIT("GEV");
      }


      String VendorName() const noexcept
      {
        auto vendorName = Node(CVB_LIT("DeviceVendorName"));
        return vendorName != nullptr ? vendorName->DisplayName() : CVB_LIT("STEMMERIMAGING");
      }


      GenApi::NodeMap::GenApiVersion XmlFileSchemaVersion() const noexcept
      {
        return GenApi::NodeMap::GenApiVersion(1, 0, 1);
      }

      GenApi::NodeMap::GenApiVersion XmlFileVersion() const noexcept
      {
        return GenApi::NodeMap::GenApiVersion(static_cast<std::uint16_t>(GetInfoAsInt(Info::XMLVersionMajor)),
                                              static_cast<std::uint16_t>(GetInfoAsInt(Info::XMLVersionMinor)),
                                              static_cast<std::uint16_t>(GetInfoAsInt(Info::XMLVersionSubMinor)));
      }

      void SetXmlFileVersion(const GenApi::NodeMap::GenApiVersion &genApiVersion) const
      {
        SetInfoAsInt(Info::XMLVersionMajor, genApiVersion.Major());
        SetInfoAsInt(Info::XMLVersionMinor, genApiVersion.Minor());
        SetInfoAsInt(Info::XMLVersionSubMinor, genApiVersion.SubMinor());
      }


      template <class T>
      std::shared_ptr<T> Node(const String &name) const
      {
        static_assert(std::is_base_of<Cvb::GevServer::Node, T>::value, "requested node type must be derived from Node");
        return std::dynamic_pointer_cast<T>(Node(name));
      }


      NodePtr Node(const String &name) const
      {
        auto nameOnly = GevServer::Node::ParseName(name);
        if (nodes_.find(nameOnly) == nodes_.end())
          throw std::out_of_range("no node for name");
 
        auto node = nodes_[nameOnly];
        if (!node)
        {
          node             = Node::FromName(std::const_pointer_cast<NodeMap>(shared_from_this()), nameOnly);
          nodes_[nameOnly] = node;
        }
 
        return node;
      }


      template <class T>
      std::shared_ptr<T> TryGetNode(const String &name) const
      {
        static_assert(std::is_base_of<Cvb::GevServer::Node, T>::value, "requested node type must be derived from Node");
        return std::dynamic_pointer_cast<T>(TryGetNode(name));
      }


      NodePtr TryGetNode(const String &name) const noexcept
      {
        NodePtr node = NodePtr();
        try
        {
          node = Node(name);
        }
        catch (...)
        {
        }
        return node;
      }
 
    private:
      void FillNodeKeys();
 
      std::string GetLastGSErrorMessage() const noexcept
      {
        std::size_t messageSize = 0;
        auto res                = CVB_CALL_CAPI(GSGetLastErrorString(nullptr, messageSize));
        if (!res || messageSize < 2)
          return {};
        std::vector<char> message(messageSize);
        if (CVB_CALL_CAPI(GSGetLastErrorString(message.data(), messageSize)))
          return {};
        return std::string(message.data());
      }
 
      void NativeCall(std::function<CExports::cvbres_t()> fn) const
      {
        auto result = fn();
        if (result < 0)
        {
          auto message = GetLastGSErrorMessage();
          if (message.empty())
            message = "Error";
 
          std::stringstream stream;
          stream << "NodeMap: " << 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;
          stream << "NodeMap: " << message;
          std::rethrow_exception(CvbException::FromCvbResult(result, stream.str()));
        }
        return value;
      }
 
      std::int64_t GetInfoAsInt(Info command) const
      {
        return static_cast<std::int64_t>(NativeCall<CExports::cvbint64_t>([&](CExports::cvbint64_t &value) {
          return CVB_CALL_CAPI(GSGetInfoAsInteger(Handle(), static_cast<CExports::TGSInfo>(command), value));
        }));
      }
 
      void SetInfoAsInt(Info command, CExports::cvbint64_t value) const
      {
        NativeCall([&]() {
          return CVB_CALL_CAPI(GSSetInfoAsInteger(Handle(), static_cast<CExports::TGSInfo>(command), value));
        });
      }
 
      std::weak_ptr<class Server> server_;
      mutable std::map<String, std::shared_ptr<class Node>> nodes_;
    };
  }  // namespace GevServer
  CVB_END_INLINE_NS
}  // namespace Cvb