decl_node.hpp

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



    class Node
    {
    public:
      using GuardType = HandleGuard<Node>;
 
      template <class T>
      static std::shared_ptr<T> FromHandle(HandleGuard<Node> &&guard)
      {
        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 Node");
        return std::make_shared<T>(std::move(guard));
      }
 
      static NodePtr FromName(const NodeMapPtr &nodeMap, const String &name);
 
      Node(const Node &other)            = delete;
      Node &operator=(const Node &other) = delete;
      Node(Node &&other)                 = delete;
      Node &&operator=(Node &&other)     = delete;
 
      virtual ~Node()
      {
        if (nativeUpdateRegistered_)
          CExports::NDeregisterUpdate(Handle(), cbID_);
      }


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


      String Name() const
      {
        return GetInfoAsString(NodeInfo::Name);
      }


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


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


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


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


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


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


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


      bool IsWriteable() const
      {
        return AccessMode() == Cvb::GenApi::AccessMode::WriteOnly || AccessMode() == Cvb::GenApi::AccessMode::ReadWrite;
      }


      Cvb::GenApi::CacheMode CacheMode() const
      {
        return static_cast<Cvb::GenApi::CacheMode>(GetInfoAsInt(NodeInfo::CachingMode));
      }


      String EventID() const
      {
        return GetInfoAsString(NodeInfo::EventID);
      }


      bool IsFeature() const
      {
        return GetInfoAsBool(NodeInfo::Feature);
      }


      bool IsDeprecated() const
      {
        return GetInfoAsBool(NodeInfo::Deprecated);
      }


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


      NodePtr AliasNode() const;


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


      void UnregisterEventUpdated(EventCookie eventCookie) noexcept;


      NodeMapPtr NodeMap() const noexcept
      {
        return nodeMap_;
      }
 
    protected:
      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;
      }
 
      bool GetInfoAsBool(NodeInfo command) const
      {
        return (NativeCall<CExports::cvbbool_t>([&](CExports::cvbbool_t &value) {
          return CExports::NInfoAsBoolean(Handle(), static_cast<CExports::TNodeInfo>(command), value);
        }))
                   ? true
                   : false;
      }
 
      std::int64_t GetInfoAsInt(NodeInfo command) const
      {
        return static_cast<std::int64_t>(NativeCall<CExports::cvbint64_t>([&](CExports::cvbint64_t &value) {
          return CExports::NInfoAsInteger(Handle(), static_cast<CExports::TNodeInfo>(command), value);
        }));
      }
 
      String GetInfoAsString(NodeInfo command) const
      {
        return NativeCall<String>([&](String &value) {
          std::size_t bufferSize = 0;
          auto bufferSizeResult  = CExports::NInfoAsStringTyped(Handle(), static_cast<CExports::TNodeInfo>(command),
                                                                reinterpret_cast<Char *>(0), bufferSize);
          if (bufferSizeResult < 0)
            return bufferSizeResult;
 
          std::vector<Char> buffer(bufferSize);
          auto bufferResult = CExports::NInfoAsStringTyped(Handle(), static_cast<CExports::TNodeInfo>(command),
                                                           buffer.data(), bufferSize);
          if (bufferResult < 0)
            return bufferResult;
 
          value = String(buffer.data());
          return bufferResult;
        });
      }
 
      int GetDependentNodeCount(NodeList type) const
      {
        CExports::cvbdim_t numNodes = 0;
        auto result                 = CExports::NListCount(Handle(), static_cast<CExports::TNodeList>(type), numNodes);
        if (result < 0 && result != ErrorCodes::CVB_WRONGOBJECT)
          std::rethrow_exception(CvbException::FromCvbResult(result, "failed calling NListCount"));
 
        return numNodes;
      }
 
      template <class T>
      std::vector<std::shared_ptr<T>> GetDependentNodes(NodeList type) const;
 
      explicit Node(HandleGuard<Node> &&guard) noexcept
          : handle_(std::move(guard))
      {
      }
 
    private:
      friend class NodeMap;
 
      static NodePtr FromHandle(const NodeMapPtr &nodeMap, HandleGuard<Node> &&guard);
 
      static void __stdcall UpdatedCallback(CExports::NODE, void *pPrivate)
      {
        try
        {
          auto node = reinterpret_cast<Node *>(pPrivate);
          node->updatedCarrierContainer_.Call<void(Node &)>(*node);
        }
        catch (...)
        {
          // swallow exception so they don't propagate to native library.
        }
      }
 
      bool IsRegisterNode() const noexcept
      {
        CExports::cvbint64_t value = 0;
        return CExports::NInfoAsInteger(Handle(), static_cast<CExports::TNodeInfo>(NodeInfo::RegisterLength), value)
                   >= 0
               && value > 0;
      }
 
      HandleGuard<Node> handle_;
 
      NodeMapPtr nodeMap_;
 
      Internal::CarrierContainer updatedCarrierContainer_;
 
      std::mutex nativeUpdateRegistrationMutex_;
 
      void *cbID_ = nullptr;
 
      bool nativeUpdateRegistered_ = false;
    };
 
  }  // namespace GenApi
 
  using GenApi::Node;
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb