peak_register_node.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common_c/detail/peak_common_defines.h>
 
#include <peak/backend/peak_backend.h>
#include <peak/dll_interface/peak_dll_interface_util.hpp>
#include <peak/error_handling/peak_error_handling.hpp>
#include <peak/node_map/peak_common_node_enums.hpp>
#include <peak/node_map/peak_node.hpp>
 
#include <type_traits>
#include <cstddef>
#include <cstdint>
#include <vector>
 
 
namespace peak
{
namespace core
{
namespace nodes
{

class RegisterNode : public Node
{
public:
    static constexpr auto NodeType = nodes::NodeType::Register;
    using NodeDataType = std::vector<uint8_t>;
    using NodeHasRange = std::false_type;
 
    RegisterNode() = delete;
    ~RegisterNode() override = default;
    RegisterNode(const RegisterNode& other) = delete;
    RegisterNode& operator=(const RegisterNode& other) = delete;
    RegisterNode(RegisterNode&& other) = delete;
    RegisterNode& operator=(RegisterNode&& other) = delete;

    PEAK_COMMON_NO_DISCARD uint64_t Address() const;

    PEAK_COMMON_NO_DISCARD size_t Length() const;

    PEAK_COMMON_NO_DISCARD std::vector<uint8_t> Read(
        size_t numBytes, NodeCacheUsePolicy cacheUsePolicy = NodeCacheUsePolicy::UseCache) const;

    PEAK_COMMON_NO_DISCARD std::vector<uint8_t> ReadAll(
        NodeCacheUsePolicy cacheUsePolicy = NodeCacheUsePolicy::UseCache) const;

    void Write(const std::vector<uint8_t>& bytes);

    void Write(const uint8_t* bytes, size_t size);
 
private:
    friend ClassCreator<RegisterNode>;
    RegisterNode(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, const std::weak_ptr<NodeMap>& parentNodeMap);
    PEAK_REGISTER_NODE_HANDLE m_backendHandle;
};
 
} /* namespace nodes */
} /* namespace core */
} /* namespace peak */
 
/* Implementation */
namespace peak
{
namespace core
{
namespace nodes
{
 
inline RegisterNode::RegisterNode(
    PEAK_REGISTER_NODE_HANDLE registerNodeHandle, const std::weak_ptr<NodeMap>& parentNodeMap)
    : Node(QueryNumericFromCInterfaceFunction<PEAK_NODE_HANDLE>([&](PEAK_NODE_HANDLE* nodeHandle) {
        return PEAK_C_ABI_PREFIX PEAK_RegisterNode_ToNode(registerNodeHandle, nodeHandle);
    }),
          parentNodeMap)
    , m_backendHandle(registerNodeHandle)
{}
 
inline uint64_t RegisterNode::Address() const
{
    return QueryNumericFromCInterfaceFunction<uint64_t>([&](uint64_t* address) {
        return PEAK_C_ABI_PREFIX PEAK_RegisterNode_GetAddress(m_backendHandle, address);
    });
}
 
inline size_t RegisterNode::Length() const
{
    return QueryNumericFromCInterfaceFunction<size_t>(
        [&](size_t* length) { return PEAK_C_ABI_PREFIX PEAK_RegisterNode_GetLength(m_backendHandle, length); });
}
 
inline std::vector<uint8_t> RegisterNode::Read(
    size_t numBytes, NodeCacheUsePolicy cacheUsePolicy /* = NodeCacheUsePolicy::UseCache */) const
{
    std::vector<uint8_t> bytes(numBytes);
    ExecuteAndMapReturnCodes([&] {
        return PEAK_C_ABI_PREFIX PEAK_RegisterNode_Read(
            m_backendHandle, static_cast<PEAK_NODE_CACHE_USE_POLICY>(cacheUsePolicy), bytes.data(), bytes.size());
    });
 
    return bytes;
}
 
inline std::vector<uint8_t> RegisterNode::ReadAll(NodeCacheUsePolicy cacheUsePolicy) const
{
    return Read(Length(), cacheUsePolicy);
}
 
inline void RegisterNode::Write(const std::vector<uint8_t>& bytes)
{
    Write(bytes.data(), bytes.size());
}
 
inline void RegisterNode::Write(const uint8_t* bytes, size_t size)
{
    ExecuteAndMapReturnCodes(
        [&] { return PEAK_C_ABI_PREFIX PEAK_RegisterNode_Write(m_backendHandle, bytes, size); });
}
 
} /* namespace nodes */
} /* namespace core */
} /* namespace peak */