peak_node.hpp

Go to the documentation of this file.

 
#pragma once
 
 
#include <peak/backend/peak_backend.h>
#include <peak/dll_interface/peak_dll_interface_util.hpp>
#include <peak/generic/peak_t_callback_manager.hpp>
 
#include <type_traits>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
 
namespace peak
{
namespace core
{
 
class NodeMap;

namespace nodes
{

enum class NodeAccessStatus
{
    NotImplemented,
    NotAvailable,
    WriteOnly,
    ReadOnly,
    ReadWrite
};

enum class NodeCachingMode
{
    NoCache,
    WriteThrough,
    WriteAround
};

enum class NodeNamespace
{
    Custom,
    Standard
};

enum class NodeType
{
    Integer,
    Boolean,
    Command,
    Float,
    String,
    Register,
    Category,
    Enumeration,
    EnumerationEntry
};

enum class NodeVisibility
{
    Beginner,
    Expert,
    Guru,
    Invisible
};

struct NodeChangedCallbackContainer;

class Node : public std::enable_shared_from_this<Node>
{
public:
    using ChangedCallback = std::function<void(const std::shared_ptr<Node>& changedNode)>;
    using ChangedCallbackHandle = ChangedCallback*;
 
    Node() = delete;
    virtual ~Node();
    Node(const Node& other) = delete;
    Node& operator=(const Node& other) = delete;
    Node(Node&& other) = delete;
    Node& operator=(Node&& other) = delete;

    std::string Name() const;

    std::string DisplayName() const;

    NodeNamespace Namespace() const;

    NodeVisibility Visibility() const;

    NodeAccessStatus AccessStatus() const;

    bool IsReadable() const;

    bool IsWriteable() const;

    bool IsAvailable() const;

    bool IsImplemented() const;

    bool IsCacheable() const;

    bool IsAccessStatusCacheable() const;

    bool IsStreamable() const;

    bool IsDeprecated() const;

    bool IsFeature() const;

    NodeCachingMode CachingMode() const;

    int64_t PollingTime() const;

    std::string ToolTip() const;

    std::string Description() const;

    NodeType Type() const;

    std::shared_ptr<NodeMap> ParentNodeMap() const;

    std::shared_ptr<Node> FindInvalidatedNode(const std::string& name) const;

    template <class NodeType, typename std::enable_if<std::is_base_of<Node, NodeType>::value, int>::type = 0>
    std::shared_ptr<NodeType> FindInvalidatedNode(const std::string& name) const
    {
        auto castedNode = std::dynamic_pointer_cast<NodeType>(FindInvalidatedNode(name));
        if (!castedNode)
        {
            throw InvalidCastException("Invalid node cast!");
        }
 
        return castedNode;
    }

    std::vector<std::shared_ptr<Node>> InvalidatedNodes() const;

    std::shared_ptr<Node> FindInvalidatingNode(const std::string& name) const;

    template <class NodeType, typename std::enable_if<std::is_base_of<Node, NodeType>::value, int>::type = 0>
    std::shared_ptr<NodeType> FindInvalidatingNode(const std::string& name) const
    {
        auto castedNode = std::dynamic_pointer_cast<NodeType>(FindInvalidatingNode(name));
        if (!castedNode)
        {
            throw InvalidCastException("Invalid node cast!");
        }
 
        return castedNode;
    }

    std::vector<std::shared_ptr<Node>> InvalidatingNodes() const;

    std::shared_ptr<Node> FindSelectedNode(const std::string& name) const;

    template <class NodeType, typename std::enable_if<std::is_base_of<Node, NodeType>::value, int>::type = 0>
    std::shared_ptr<NodeType> FindSelectedNode(const std::string& name) const
    {
        auto castedNode = std::dynamic_pointer_cast<NodeType>(FindSelectedNode(name));
        if (!castedNode)
        {
            throw InvalidCastException("Invalid node cast!");
        }
 
        return castedNode;
    }

    std::vector<std::shared_ptr<Node>> SelectedNodes() const;

    std::shared_ptr<Node> FindSelectingNode(const std::string& name) const;

    template <class NodeType, typename std::enable_if<std::is_base_of<Node, NodeType>::value, int>::type = 0>
    std::shared_ptr<NodeType> FindSelectingNode(const std::string& name) const
    {
        auto castedNode = std::dynamic_pointer_cast<NodeType>(FindSelectingNode(name));
        if (!castedNode)
        {
            throw InvalidCastException("Invalid node cast!");
        }
 
        return castedNode;
    }

    std::vector<std::shared_ptr<Node>> SelectingNodes() const;

    ChangedCallbackHandle RegisterChangedCallback(const ChangedCallback& callback);

    void UnregisterChangedCallback(ChangedCallbackHandle callbackHandle);
 
protected:
    Node(PEAK_NODE_HANDLE nodeHandle, const std::weak_ptr<peak::core::NodeMap>& parentNodeMap);
private:
    struct NodeChangedCallbackContainer
    {
        std::shared_ptr<Node> _Node;
        Node::ChangedCallback Callback;
    };
    static void PEAK_CALL_CONV ChangedCallbackCWrapper(PEAK_NODE_HANDLE, void* context);
 
    friend ClassCreator<Node>;
    PEAK_NODE_HANDLE m_backendHandle;
 
    std::weak_ptr<NodeMap> m_parentNodeMap;
 
    std::unique_ptr<TCallbackManager<PEAK_NODE_CHANGED_CALLBACK_HANDLE, NodeChangedCallbackContainer>>
        m_changedCallbackManager;
};
 
inline std::string GetNodeName(PEAK_NODE_HANDLE nodeHandle)
{
    return QueryStringFromCInterfaceFunction([&](char* nodeName, size_t* nodeNameSize) {
        return PEAK_C_ABI_PREFIX PEAK_Node_GetName(nodeHandle, nodeName, nodeNameSize);
    });
}
 
} /* namespace nodes */
} /* namespace core */
} /* namespace peak */
 
#include <peak/node_map/peak_node_map.hpp>
 
/* Implementation */
namespace peak
{
namespace core
{
namespace nodes
{
 
inline std::string ToString(NodeAccessStatus entry)
{
    std::string entryString;
 
    if (entry == NodeAccessStatus::NotImplemented)
    {
        entryString = "NotImplemented";
    }
    else if (entry == NodeAccessStatus::NotAvailable)
    {
        entryString = "NotAvailable";
    }
    else if (entry == NodeAccessStatus::WriteOnly)
    {
        entryString = "WriteOnly";
    }
    else if (entry == NodeAccessStatus::ReadOnly)
    {
        entryString = "ReadOnly";
    }
    else if (entry == NodeAccessStatus::ReadWrite)
    {
        entryString = "ReadWrite";
    }
 
    return entryString;
}
 
inline std::string ToString(NodeCachingMode entry)
{
    std::string entryString;
 
    if (entry == NodeCachingMode::NoCache)
    {
        entryString = "NoCache";
    }
    else if (entry == NodeCachingMode::WriteThrough)
    {
        entryString = "WriteThrough";
    }
    else if (entry == NodeCachingMode::WriteAround)
    {
        entryString = "WriteAround";
    }
 
    return entryString;
}
 
inline std::string ToString(NodeNamespace entry)
{
    std::string entryString;
 
    if (entry == NodeNamespace::Custom)
    {
        entryString = "Custom";
    }
    else if (entry == NodeNamespace::Standard)
    {
        entryString = "Standard";
    }
 
    return entryString;
}
 
inline std::string ToString(NodeType entry)
{
    std::string entryString;
 
    if (entry == NodeType::Integer)
    {
        entryString = "Integer";
    }
    else if (entry == NodeType::Boolean)
    {
        entryString = "Boolean";
    }
    else if (entry == NodeType::Command)
    {
        entryString = "Command";
    }
    else if (entry == NodeType::Float)
    {
        entryString = "Float";
    }
    else if (entry == NodeType::String)
    {
        entryString = "String";
    }
    else if (entry == NodeType::Register)
    {
        entryString = "Register";
    }
    else if (entry == NodeType::Category)
    {
        entryString = "Category";
    }
    else if (entry == NodeType::Enumeration)
    {
        entryString = "Enumeration";
    }
    else if (entry == NodeType::EnumerationEntry)
    {
        entryString = "EnumerationEntry";
    }
 
    return entryString;
}
 
inline std::string ToString(NodeVisibility entry)
{
    std::string entryString;
 
    if (entry == NodeVisibility::Beginner)
    {
        entryString = "Beginner";
    }
    else if (entry == NodeVisibility::Expert)
    {
        entryString = "Expert";
    }
    else if (entry == NodeVisibility::Guru)
    {
        entryString = "Guru";
    }
    else if (entry == NodeVisibility::Invisible)
    {
        entryString = "Invisible";
    }
 
    return entryString;
}

inline Node::Node(PEAK_NODE_HANDLE nodeHandle, const std::weak_ptr<peak::core::NodeMap>& parentNodeMap)
    : m_backendHandle(nodeHandle)
    , m_parentNodeMap(parentNodeMap)
    , m_changedCallbackManager()
{
    m_changedCallbackManager =
        std::make_unique<TCallbackManager<PEAK_NODE_CHANGED_CALLBACK_HANDLE, NodeChangedCallbackContainer>>(
            [&](void* callbackContext) {
                return QueryNumericFromCInterfaceFunction<PEAK_NODE_CHANGED_CALLBACK_HANDLE>(
                    [&](PEAK_NODE_CHANGED_CALLBACK_HANDLE* nodeChangedCallbackHandle) {
                        return PEAK_C_ABI_PREFIX PEAK_Node_RegisterChangedCallback(
                            m_backendHandle, ChangedCallbackCWrapper, callbackContext, nodeChangedCallbackHandle);
                    });
            },
            [&](PEAK_NODE_CHANGED_CALLBACK_HANDLE callbackHandle) {
                CallAndCheckCInterfaceFunction([&] {
                    return PEAK_C_ABI_PREFIX PEAK_Node_UnregisterChangedCallback(m_backendHandle, callbackHandle);
                });
            });
}
 
inline Node::~Node()
{
    m_changedCallbackManager->UnregisterAllCallbacks();
}
 
inline std::string Node::Name() const
{
    return GetNodeName(m_backendHandle);
}
 
inline std::string Node::DisplayName() const
{
    return QueryStringFromCInterfaceFunction([&](char* displayName, size_t* displayNameSize) {
        return PEAK_C_ABI_PREFIX PEAK_Node_GetDisplayName(m_backendHandle, displayName, displayNameSize);
    });
}
 
inline NodeNamespace Node::Namespace() const
{
    return static_cast<NodeNamespace>(
        QueryNumericFromCInterfaceFunction<PEAK_NODE_NAMESPACE>([&](PEAK_NODE_NAMESPACE* _namespace) {
            return PEAK_C_ABI_PREFIX PEAK_Node_GetNamespace(m_backendHandle, _namespace);
        }));
}
 
inline NodeVisibility Node::Visibility() const
{
    return static_cast<NodeVisibility>(
        QueryNumericFromCInterfaceFunction<PEAK_NODE_VISIBILITY>([&](PEAK_NODE_VISIBILITY* visibility) {
            return PEAK_C_ABI_PREFIX PEAK_Node_GetVisibility(m_backendHandle, visibility);
        }));
}
 
inline NodeAccessStatus Node::AccessStatus() const
{
    return static_cast<NodeAccessStatus>(
        QueryNumericFromCInterfaceFunction<PEAK_NODE_ACCESS_STATUS>([&](PEAK_NODE_ACCESS_STATUS* accessStatus) {
            return PEAK_C_ABI_PREFIX PEAK_Node_GetAccessStatus(m_backendHandle, accessStatus);
        }));
}
 
inline bool Node::IsReadable() const
{
    const auto accessStatus = AccessStatus();
    return accessStatus == NodeAccessStatus::ReadOnly || accessStatus == NodeAccessStatus::ReadWrite;
}
 
inline bool Node::IsWriteable() const
{
    const auto accessStatus = AccessStatus();
    return accessStatus == NodeAccessStatus::WriteOnly || accessStatus == NodeAccessStatus::ReadWrite;
}
 
inline bool Node::IsAvailable() const
{
    const auto accessStatus = AccessStatus();
    return accessStatus != NodeAccessStatus::NotImplemented && accessStatus != NodeAccessStatus::NotAvailable;
}
 
inline bool Node::IsImplemented() const
{
    const auto accessStatus = AccessStatus();
    return accessStatus != NodeAccessStatus::NotImplemented;
}
 
 
 
inline bool Node::IsCacheable() const
{
    return QueryNumericFromCInterfaceFunction<PEAK_BOOL8>([&](PEAK_BOOL8* isCacheable) {
        return PEAK_C_ABI_PREFIX PEAK_Node_GetIsCacheable(m_backendHandle, isCacheable);
    }) > 0;
}
 
inline bool Node::IsAccessStatusCacheable() const
{
    return QueryNumericFromCInterfaceFunction<PEAK_BOOL8>([&](PEAK_BOOL8* isAccessStatusCacheable) {
        return PEAK_C_ABI_PREFIX PEAK_Node_GetIsAccessStatusCacheable(m_backendHandle, isAccessStatusCacheable);
    }) > 0;
}
 
inline bool Node::IsStreamable() const
{
    return QueryNumericFromCInterfaceFunction<PEAK_BOOL8>([&](PEAK_BOOL8* isStreamable) {
        return PEAK_C_ABI_PREFIX PEAK_Node_GetIsStreamable(m_backendHandle, isStreamable);
    }) > 0;
}
 
inline bool Node::IsDeprecated() const
{
    return QueryNumericFromCInterfaceFunction<PEAK_BOOL8>([&](PEAK_BOOL8* isDeprecated) {
        return PEAK_C_ABI_PREFIX PEAK_Node_GetIsDeprecated(m_backendHandle, isDeprecated);
    }) > 0;
}
 
inline bool Node::IsFeature() const
{
    return QueryNumericFromCInterfaceFunction<PEAK_BOOL8>([&](PEAK_BOOL8* isFeature) {
        return PEAK_C_ABI_PREFIX PEAK_Node_GetIsFeature(m_backendHandle, isFeature);
    }) > 0;
}
 
inline NodeCachingMode Node::CachingMode() const
{
    return static_cast<NodeCachingMode>(
        QueryNumericFromCInterfaceFunction<PEAK_NODE_CACHING_MODE>([&](PEAK_NODE_CACHING_MODE* cachingMode) {
            return PEAK_C_ABI_PREFIX PEAK_Node_GetCachingMode(m_backendHandle, cachingMode);
        }));
}
 
inline int64_t Node::PollingTime() const
{
    return QueryNumericFromCInterfaceFunction<int64_t>([&](int64_t* pollingTime_ms) {
        return PEAK_C_ABI_PREFIX PEAK_Node_GetPollingTime(m_backendHandle, pollingTime_ms);
    });
}
 
inline std::string Node::ToolTip() const
{
    return QueryStringFromCInterfaceFunction([&](char* toolTip, size_t* toolTipSize) {
        return PEAK_C_ABI_PREFIX PEAK_Node_GetToolTip(m_backendHandle, toolTip, toolTipSize);
    });
}
 
inline std::string Node::Description() const
{
    return QueryStringFromCInterfaceFunction([&](char* description, size_t* descriptionSize) {
        return PEAK_C_ABI_PREFIX PEAK_Node_GetDescription(m_backendHandle, description, descriptionSize);
    });
}
 
inline NodeType Node::Type() const
{
    return static_cast<NodeType>(QueryNumericFromCInterfaceFunction<PEAK_NODE_TYPE>(
        [&](PEAK_NODE_TYPE* type) { return PEAK_C_ABI_PREFIX PEAK_Node_GetType(m_backendHandle, type); }));
}
 
inline std::shared_ptr<peak::core::NodeMap> Node::ParentNodeMap() const
{
    return LockOrThrow(m_parentNodeMap);
}
 
inline std::shared_ptr<Node> Node::FindInvalidatedNode(const std::string& name) const
{
    auto nodeHandle = QueryNumericFromCInterfaceFunction<PEAK_NODE_HANDLE>([&](PEAK_NODE_HANDLE* _nodeHandle) {
        return PEAK_C_ABI_PREFIX PEAK_Node_FindInvalidatedNode(
            m_backendHandle, name.c_str(), name.size() + 1, _nodeHandle);
    });
 
    auto nodeName = GetNodeName(nodeHandle);
 
    return ParentNodeMap()->FindNode(name);
}
 
inline std::vector<std::shared_ptr<Node>> Node::InvalidatedNodes() const
{
    auto numInvalidatedNodes = QueryNumericFromCInterfaceFunction<size_t>([&](size_t* _numInvalidatedNodes) {
        return PEAK_C_ABI_PREFIX PEAK_Node_GetNumInvalidatedNodes(m_backendHandle, _numInvalidatedNodes);
    });
 
    std::vector<std::shared_ptr<Node>> invalidatedNodes;
    for (size_t x = 0; x < numInvalidatedNodes; ++x)
    {
        auto nodeHandle = QueryNumericFromCInterfaceFunction<PEAK_NODE_HANDLE>(
            [&](PEAK_NODE_HANDLE* _nodeHandle) {
                return PEAK_C_ABI_PREFIX PEAK_Node_GetInvalidatedNode(m_backendHandle, x, _nodeHandle);
            });
 
        auto nodeName = GetNodeName(nodeHandle);
 
        invalidatedNodes.emplace_back(ParentNodeMap()->FindNode(nodeName));
    }
 
    return invalidatedNodes;
}
 
inline std::shared_ptr<Node> Node::FindInvalidatingNode(const std::string& name) const
{
    auto nodeHandle = QueryNumericFromCInterfaceFunction<PEAK_NODE_HANDLE>([&](PEAK_NODE_HANDLE* _nodeHandle) {
        return PEAK_C_ABI_PREFIX PEAK_Node_FindInvalidatingNode(
            m_backendHandle, name.c_str(), name.size() + 1, _nodeHandle);
    });
 
    auto nodeName = GetNodeName(nodeHandle);
 
    return ParentNodeMap()->FindNode(name);
}
 
inline std::vector<std::shared_ptr<Node>> Node::InvalidatingNodes() const
{
    auto numInvalidatingNodes = QueryNumericFromCInterfaceFunction<size_t>([&](size_t* _numInvalidatedNodes) {
        return PEAK_C_ABI_PREFIX PEAK_Node_GetNumInvalidatingNodes(m_backendHandle, _numInvalidatedNodes);
    });
 
    std::vector<std::shared_ptr<Node>> invalidatingNodes;
    for (size_t x = 0; x < numInvalidatingNodes; ++x)
    {
        auto nodeHandle = QueryNumericFromCInterfaceFunction<PEAK_NODE_HANDLE>(
            [&](PEAK_NODE_HANDLE* _nodeHandle) {
                return PEAK_C_ABI_PREFIX PEAK_Node_GetInvalidatingNode(m_backendHandle, x, _nodeHandle);
            });
 
        auto nodeName = GetNodeName(nodeHandle);
 
        invalidatingNodes.emplace_back(ParentNodeMap()->FindNode(nodeName));
    }
 
    return invalidatingNodes;
}
 
inline std::shared_ptr<Node> Node::FindSelectedNode(const std::string& name) const
{
    auto nodeHandle = QueryNumericFromCInterfaceFunction<PEAK_NODE_HANDLE>([&](PEAK_NODE_HANDLE* _nodeHandle) {
        return PEAK_C_ABI_PREFIX PEAK_Node_FindSelectedNode(
            m_backendHandle, name.c_str(), name.size() + 1, _nodeHandle);
    });
 
    auto nodeName = GetNodeName(nodeHandle);
 
    return ParentNodeMap()->FindNode(name);
}
 
inline std::vector<std::shared_ptr<Node>> Node::SelectedNodes() const
{
    auto numSelectedNodes = QueryNumericFromCInterfaceFunction<size_t>([&](size_t* _numSelectedNodes) {
        return PEAK_C_ABI_PREFIX PEAK_Node_GetNumSelectedNodes(m_backendHandle, _numSelectedNodes);
    });
 
    std::vector<std::shared_ptr<Node>> selectedNodes;
    for (size_t x = 0; x < numSelectedNodes; ++x)
    {
        auto nodeHandle = QueryNumericFromCInterfaceFunction<PEAK_NODE_HANDLE>(
            [&](PEAK_NODE_HANDLE* _nodeHandle) {
                return PEAK_C_ABI_PREFIX PEAK_Node_GetSelectedNode(m_backendHandle, x, _nodeHandle);
            });
 
        auto nodeName = GetNodeName(nodeHandle);
 
        selectedNodes.emplace_back(ParentNodeMap()->FindNode(nodeName));
    }
 
    return selectedNodes;
}
 
inline std::shared_ptr<Node> Node::FindSelectingNode(const std::string& name) const
{
    auto nodeHandle = QueryNumericFromCInterfaceFunction<PEAK_NODE_HANDLE>([&](PEAK_NODE_HANDLE* _nodeHandle) {
        return PEAK_C_ABI_PREFIX PEAK_Node_FindSelectingNode(
            m_backendHandle, name.c_str(), name.size() + 1, _nodeHandle);
    });
 
    auto nodeName = GetNodeName(nodeHandle);
 
    return ParentNodeMap()->FindNode(name);
}
 
inline std::vector<std::shared_ptr<Node>> Node::SelectingNodes() const
{
    auto numSelectingNodes = QueryNumericFromCInterfaceFunction<size_t>([&](size_t* _numSelectingNodes) {
        return PEAK_C_ABI_PREFIX PEAK_Node_GetNumSelectingNodes(m_backendHandle, _numSelectingNodes);
    });
 
    std::vector<std::shared_ptr<Node>> selectingNodes;
    for (size_t x = 0; x < numSelectingNodes; ++x)
    {
        auto nodeHandle = QueryNumericFromCInterfaceFunction<PEAK_NODE_HANDLE>(
            [&](PEAK_NODE_HANDLE* _nodeHandle) {
                return PEAK_C_ABI_PREFIX PEAK_Node_GetSelectingNode(m_backendHandle, x, _nodeHandle);
            });
 
        auto nodeName = GetNodeName(nodeHandle);
 
        selectingNodes.emplace_back(ParentNodeMap()->FindNode(nodeName));
    }
 
    return selectingNodes;
}
 
inline Node::ChangedCallbackHandle Node::RegisterChangedCallback(const Node::ChangedCallback& callback)
{
    return reinterpret_cast<ChangedCallbackHandle>(
        m_changedCallbackManager->RegisterCallback(NodeChangedCallbackContainer{ shared_from_this(), callback }));
}
 
inline void Node::UnregisterChangedCallback(Node::ChangedCallbackHandle callbackHandle)
{
    m_changedCallbackManager->UnregisterCallback(
        reinterpret_cast<PEAK_NODE_CHANGED_CALLBACK_HANDLE>(callbackHandle));
}
 
inline void PEAK_CALL_CONV Node::ChangedCallbackCWrapper(PEAK_NODE_HANDLE, void* context)
{
    auto callbackContainer = static_cast<NodeChangedCallbackContainer*>(context);
 
    callbackContainer->Callback(callbackContainer->_Node);
}
 
} /* namespace nodes */
} /* namespace core */
} /* namespace peak */