decl_node.hpp

#pragma once
 
#include <cassert>
#include <functional>
#include <iomanip>
#include <memory>
#include <vector>
 
#include "../../exception.hpp"
#include "../../global.hpp"
#include "../../string.hpp"
#include "../../utilities/system_info.hpp"
 
#include "../_detail/ihas_value_config.hpp"
 
#include "../../genapi/genapi.hpp"
#include "../gevserver.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  template <>
  inline HandleGuard<GevServer::Node>::HandleGuard(void *handle) noexcept
      : HandleGuard<GevServer::Node>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
  namespace GevServer
  {

    class Node
    {
      friend class NodeMap;
 
    public:
      explicit Node(HandleGuard<Node> &&guard) noexcept
          : handle_(std::move(guard))
      {
      }
 
      Node(const Node &other)            = delete;
      Node &operator=(const Node &other) = delete;
      Node(Node &&other)                 = delete;
      Node &operator=(Node &&other)      = delete;
      virtual ~Node()                    = default;

      static NodePtr FromName(const NodeMapPtr &nodeMap, const String &name);

      template <class T, class... ARGS>
      static std::shared_ptr<T> FromHandle(HandleGuard<Node> &&guard, ARGS &&...args)
      {
        if (!guard.Handle())
          throw std::runtime_error("handle must not be null");
 
        static_assert(std::is_base_of<Node, T>::value, "CVB: Type must be derived from Device");
        auto node = std::shared_ptr<T>(new T(std::move(guard), std::forward<ARGS>(args)...));
        return node;
      }
      static std::shared_ptr<T> FromHandle(HandleGuard<Node> &&guard, ARGS &&...args) {…}

      void Add(const NodePtr &item, const NodeList &kind);

      bool Remove(const NodePtr &item, const NodeList &kind);


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

      // Can also be null
      NodeMapPtr NodeMap() const
      {
        return nodeMap_.lock();
      }
      NodeMapPtr NodeMap() const {…}


      String ToolTip() const
      {
        return GetInfoAsString(NodeInfo::ToolTip);
      }
      String ToolTip() const {…}


      void SetToolTip(const String &value)
      {
        if (value.empty())
          throw std::runtime_error("Tooltip short descriptive text must not be empty");
        SetInfo(NodeInfo::ToolTip, value);
      }
      void SetToolTip(const String &value) {…}


      String Description() const
      {
        return GetInfoAsString(NodeInfo::Description);
      }
      String Description() const {…}


      void SetDescription(const String &value)
      {
        if (value.empty())
          throw std::runtime_error("Description must not be empty");
        SetInfo(NodeInfo::Description, value);
      }
      void SetDescription(const String &value) {…}

      virtual GenApi::AccessMode AccessMode() const;

      Cvb::GenApi::AccessMode ImposedAccessMode() const;

      void SetImposedAccessMode(const Cvb::GenApi::AccessMode &accessMode);


      bool IsImplemented() const
      {
        return AccessMode() != Cvb::GenApi::AccessMode::NotImplemented;
      }
      bool IsImplemented() const {…}

      IntegerBaseNodePtr IsImplementedConfig() const;

      void SetIsImplementedConfig(const IntegerBaseNodePtr &node);


      bool IsAvailable() const
      {
        return AccessMode() != Cvb::GenApi::AccessMode::NotImplemented
               && AccessMode() != Cvb::GenApi::AccessMode::NotAvailable;
      }
      bool IsAvailable() const {…}

      IntegerBaseNodePtr IsAvailableConfig() const;

      void SetIsAvailableConfig(const IntegerBaseNodePtr &node);


      bool IsReadable() const
      {
        return AccessMode() == GenApi::AccessMode::ReadOnly || AccessMode() == GenApi::AccessMode::ReadWrite;
      }
      bool IsReadable() const {…}


      bool IsWritable() const
      {
        return AccessMode() == GenApi::AccessMode::WriteOnly || AccessMode() == GenApi::AccessMode::ReadWrite;
      }
      bool IsWritable() const {…}

      IntegerBaseNodePtr IsLockedConfig() const;

      void SetIsLockedConfig(const IntegerBaseNodePtr &node);


      virtual Cvb::GenApi::CacheMode CacheMode() const;


      Cvb::GenApi::Visibility Visibility() const
      {
        return static_cast<Cvb::GenApi::Visibility>(GetInfoAsInt(NodeInfo::Visibility));
      }
      Cvb::GenApi::Visibility Visibility() const {…}


      void SetVisibility(const Cvb::GenApi::Visibility &value)
      {
        SetInfoAsInt(NodeInfo::Visibility, static_cast<std::int64_t>(value));
      }
      void SetVisibility(const Cvb::GenApi::Visibility &value) {…}

      NodePtr AliasNode() const;

      void SetAliasNode(const NodePtr &value);


      String Name() const
      {
        auto nameSpace = Namespace();
        assert(nameSpace == GevServer::Namespace::Custom || nameSpace == GevServer::Namespace::Private
               ||  // NOLINT(cppcoreguidelines-pro-bounds-array-to-pointer-decay)
               nameSpace == GevServer::Namespace::Standard);
        String nsName;
        switch (nameSpace)
        {
          case GevServer::Namespace::Custom:
            nsName = CVB_LIT("Cust::");
            break;
          case GevServer::Namespace::Private:
            nsName = CVB_LIT("Priv::");
            break;
          case GevServer::Namespace::Standard:
            nsName = CVB_LIT("Std::");
            break;
        }
        return nsName + GetInfoAsString(NodeInfo::Name);
      }
      String Name() const {…}


      String NameOnly() const;

      GevServer::Namespace Namespace() const
      {
        return static_cast<GevServer::Namespace>(GetInfoAsInt(NodeInfo::NameSpace));
      }
      GevServer::Namespace Namespace() const {…}


      String EventID() const
      {
        CExports::cvbint64_t value{-1};
        auto result = CVB_CALL_CAPI(GSNGetInfoAsInteger(Handle(), CExports::TGSNodeInfo::GSNI_EventID, value));
        if (result < 0 || value < 0)
          return String();
        else
        {
          StringStream stream;
          stream << CVB_LIT("0x") << std::setfill(CVB_LIT('0')) << std::setw(sizeof(CExports::cvbint64_t) * 2)
                 << std::hex << value;
          return stream.str();
        }
      }
      String EventID() const {…}


      bool IsFeature() const;


      bool IsDeprecated() const
      {
        return false;  // Not implemented
      }
      bool IsDeprecated() const {…}


      String DisplayName() const
      {
        return GetInfoAsString(NodeInfo::DisplayName);
      }
      String DisplayName() const {…}


      void SetDisplayName(const String &value)
      {
        if (value.empty())
          throw std::runtime_error("Display name must not be empty");
        SetInfo(NodeInfo::DisplayName, value);
      }
      void SetDisplayName(const String &value) {…}


      EventCookie RegisterEventUpdated(std::function<void(Node &)> handler);


      void UnregisterEventUpdated(EventCookie eventCookie) noexcept;

      template <class NodeT, class ValueConfigNodeType>
      ValueNodePtr GetTerminalRegisterNode(const NodeT *node, std::function<bool(Node *)> f) const;
 
    protected:
      std::size_t GetDependentNodeCount(const NodeList &type) const
      {
        std::size_t numNodes = 0;
        int result = CVB_CALL_CAPI(GSNListCount(Handle(), static_cast<CExports::TGSNodeList>(type), numNodes));
        if (result < 0 && result != ErrorCodes::CVB_WRONGOBJECT)
          std::rethrow_exception(CvbException::FromCvbResult(result, "failed calling GSNListCount"));
 
        return numNodes;
      }


      template <class T>
      std::vector<std::shared_ptr<T>> GetDependentNodes(const NodeList &type) const;
 
      static std::string GetLastGSErrorMessage()
      {
        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)
          Utilities::SystemInfo::ThrowLastError(result);
      }
 
      template <class T>
      T NativeCall(std::function<CExports::cvbres_t(T &value)> fn) const
      {
        T value;
        auto result = fn(value);
        if (result < 0)
          Utilities::SystemInfo::ThrowLastError(result);
        return value;
      }
 
      static void __stdcall UpdatedCallback(void *pPrivate)
      {
        if (auto pFunction = reinterpret_cast<std::function<int(void)> *>(pPrivate))
        {
          try
          {
            (*pFunction)();
            delete pFunction;  // NOLINT(cppcoreguidelines-owning-memory)
          }
          catch (...)
          {
          }
        }
      }

      static String EnsureNodeNameOnly(const String &name)
      {
        if (name.empty())
          throw std::runtime_error("Node name must not be empty");
        if (name.find(CVB_LIT("::")) != name.npos)
          throw std::runtime_error("No namespace prefix allowed");
 
        return name;
      }
      static String EnsureNodeNameOnly(const String &name) {…}

      static NodePtr FromHandle(HandleGuard<Node> &&guard, const NodeMapPtr &nodeMap);

      static GevServer::Namespace ParseNamespace(const String &name)
      {
        if (name.empty())
          throw std::runtime_error("Node name must not be empty");
        if (name.find(CVB_LIT("::")) == name.npos)
          return GevServer::Namespace::Custom;
 
        if (name.find(CVB_LIT("Std")) != name.npos)
          return GevServer::Namespace::Standard;
        else if (name.find(CVB_LIT("Priv")) != name.npos)
          return GevServer::Namespace::Private;
        else
          return GevServer::Namespace::Custom;
      }
      static GevServer::Namespace ParseNamespace(const String &name) {…}

      static String ParseName(const String &name)
      {
        if (name.empty())
          throw std::runtime_error("Node name must not be empty");
 
        auto nameStart = name.find(CVB_LIT("::"));
        if (nameStart == name.npos)
          return name;
        auto rname = name.substr(nameStart + 2, name.length());
        return rname;
      }
      static String ParseName(const String &name) {…}
 
      bool IsRegisterNode() const noexcept
      {
        CExports::cvbint64_t value = 0;
        return CVB_CALL_CAPI(GSNGetInfoAsInteger(Handle(), CExports::TGSNodeInfo::GSNI_RegisterLength, value)) >= 0
               && value > 0;
      }
 
      template <class NodeT>
      std::shared_ptr<NodeT> GetInfoAs(const NodeInfo &info) const;


      static GevServer::NodeType NodeType(void *handle)
      {
        CExports::TGSNodeType nodeType = CExports::GSNT_Invalid;
        auto result                    = CVB_CALL_CAPI(GSNType(handle, nodeType));
        if (result < 0)
          throw std::runtime_error(GetLastGSErrorMessage());
        return static_cast<GevServer::NodeType>(nodeType);
      }
      static GevServer::NodeType NodeType(void *handle) {…}
 
      String GetInfoAsString(const NodeInfo &command) const
      {
        auto bufferSize = NativeCall<size_t>([&](size_t &size) {
          return CExports::GSNGetInfoAsStringTyped(Handle(), static_cast<CExports::TGSNodeInfo>(command),
                                                   reinterpret_cast<Char *>(0), size);
        });
 
        bufferSize += sizeof(Char);
        std::vector<Char> buffer(bufferSize);
        NativeCall([&]() {
          return CExports::GSNGetInfoAsStringTyped(Handle(), static_cast<CExports::TGSNodeInfo>(command), buffer.data(),
                                                   bufferSize);
        });
 
        return buffer.data();
      }
 
      std::int64_t GetInfoAsInt(const NodeInfo &command) const
      {
        return static_cast<std::int64_t>(NativeCall<CExports::cvbint64_t>([&](CExports::cvbint64_t &value) {
          return CVB_CALL_CAPI(GSNGetInfoAsInteger(Handle(), static_cast<CExports::TGSNodeInfo>(command), value));
        }));
      }
 
      void SetInfoAsString(const NodeInfo &command, const String &value);
 
      void SetInfoAsInt(const NodeInfo &command, const std::int64_t &value);
 
      double GetInfoAsFloat(const NodeInfo &command) const;
 
      void SetInfoAsFloat(const NodeInfo &command, const double &value);
 
      template <class NodeT>
      void SetInfo(const NodeInfo &info, const NodeT &valueNode);
 
      void SetInfo(const NodeInfo &info, const String &value);
 
    private:
      void SetNodeMap(const NodeMapPtr &nodeMap)
      {
        nodeMap_ = nodeMap;
      }
 
      bool IsFeatureIter(CategoryNodePtr parent) const;
 
      HandleGuard<Node> handle_;
      std::weak_ptr<class NodeMap> nodeMap_;
 
      std::size_t cbIDr_ = 0;
      std::size_t cbIDw_ = 0;
 
      Internal::CarrierContainer updatedCarrierContainer_;
    };
    class Node {…};
    namespace Private
    {
      // Dummy class for all unsupported node types.
      class DefaultNode : public Node
      {
      public:
        explicit DefaultNode(HandleGuard<Node> &&guard) noexcept
            : Node(std::move(guard))
        {
        }

        GenApi::AccessMode AccessMode() const override
        {
          throw std::runtime_error("not implemented");
        }

        Cvb::GenApi::CacheMode CacheMode() const override
        {
          throw std::runtime_error("not implemented");
        }
      };
    }  // namespace Private
  }  // namespace GevServer
  CVB_END_INLINE_NS
}  // namespace Cvb