peak_float_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/node_map/peak_common_node_enums.hpp>
#include <peak/node_map/peak_node.hpp>
 
#include <cstdint>
#include <string>
#include <vector>
#include <type_traits>
 
 
namespace peak
{
namespace core
{
namespace nodes
{

enum class NodeDisplayNotation
{
    Automatic,
    Fixed,
    Scientific
};

class FloatNode : public Node
{
public:
    static constexpr auto NodeType = nodes::NodeType::Float;
    using NodeDataType = double;
    using NodeHasRange = std::true_type;
 
    FloatNode() = delete;
    ~FloatNode() override = default;
    FloatNode(const FloatNode& other) = delete;
    FloatNode& operator=(const FloatNode& other) = delete;
    FloatNode(FloatNode&& other) = delete;
    FloatNode& operator=(FloatNode&& other) = delete;

    double Minimum() const;

    double Maximum() const;

    double Increment() const;

    NodeIncrementType IncrementType() const;

    std::vector<double> ValidValues() const;

    NodeRepresentation Representation() const;

    std::string Unit() const;

    NodeDisplayNotation DisplayNotation() const;

    int64_t DisplayPrecision() const;

    bool HasConstantIncrement() const;

    double Value(NodeCacheUsePolicy cacheUsePolicy = NodeCacheUsePolicy::UseCache) const;

    void SetValue(double value);
 
private:
    friend ClassCreator<FloatNode>;
    FloatNode(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, const std::weak_ptr<NodeMap>& parentNodeMap);
    PEAK_FLOAT_NODE_HANDLE m_backendHandle;
};
 
} /* namespace nodes */
} /* namespace core */
} /* namespace peak */
 
/* Implementation */
namespace peak
{
namespace core
{
namespace nodes
{
 
inline std::string ToString(NodeDisplayNotation entry)
{
    std::string entryString;
 
    if (entry == NodeDisplayNotation::Automatic)
    {
        entryString = "Automatic";
    }
    else if (entry == NodeDisplayNotation::Fixed)
    {
        entryString = "Fixed";
    }
    else if (entry == NodeDisplayNotation::Scientific)
    {
        entryString = "Scientific";
    }
 
    return entryString;
}
 
inline FloatNode::FloatNode(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, const std::weak_ptr<NodeMap>& parentNodeMap)
    : Node(QueryNumericFromCInterfaceFunction<PEAK_NODE_HANDLE>([&](PEAK_NODE_HANDLE* nodeHandle) {
        return PEAK_C_ABI_PREFIX PEAK_FloatNode_ToNode(floatNodeHandle, nodeHandle);
    }),
        parentNodeMap)
    , m_backendHandle(floatNodeHandle)
{}
 
inline double FloatNode::Minimum() const
{
    return QueryNumericFromCInterfaceFunction<double>(
        [&](double* minimum) { return PEAK_C_ABI_PREFIX PEAK_FloatNode_GetMinimum(m_backendHandle, minimum); });
}
 
inline double FloatNode::Maximum() const
{
    return QueryNumericFromCInterfaceFunction<double>(
        [&](double* maximum) { return PEAK_C_ABI_PREFIX PEAK_FloatNode_GetMaximum(m_backendHandle, maximum); });
}
 
inline double FloatNode::Increment() const
{
    return QueryNumericFromCInterfaceFunction<double>([&](double* increment) {
        return PEAK_C_ABI_PREFIX PEAK_FloatNode_GetIncrement(m_backendHandle, increment);
    });
}
 
inline NodeIncrementType FloatNode::IncrementType() const
{
    return static_cast<NodeIncrementType>(QueryNumericFromCInterfaceFunction<PEAK_NODE_INCREMENT_TYPE>(
        [&](PEAK_NODE_INCREMENT_TYPE* incrementType) {
            return PEAK_C_ABI_PREFIX PEAK_FloatNode_GetIncrementType(m_backendHandle, incrementType);
        }));
}
 
inline std::vector<double> FloatNode::ValidValues() const
{
    return QueryNumericArrayFromCInterfaceFunction<double>([&](double* validValues, size_t* validValuesSize) {
        return PEAK_C_ABI_PREFIX PEAK_FloatNode_GetValidValues(m_backendHandle, validValues, validValuesSize);
    });
}
 
inline NodeRepresentation FloatNode::Representation() const
{
    return static_cast<NodeRepresentation>(QueryNumericFromCInterfaceFunction<PEAK_NODE_REPRESENTATION>(
        [&](PEAK_NODE_REPRESENTATION* representation) {
            return PEAK_C_ABI_PREFIX PEAK_FloatNode_GetRepresentation(m_backendHandle, representation);
        }));
}
 
inline std::string FloatNode::Unit() const
{
    return QueryStringFromCInterfaceFunction([&](char* unit, size_t* unitSize) {
        return PEAK_C_ABI_PREFIX PEAK_FloatNode_GetUnit(m_backendHandle, unit, unitSize);
    });
}
 
inline NodeDisplayNotation FloatNode::DisplayNotation() const
{
    return static_cast<NodeDisplayNotation>(QueryNumericFromCInterfaceFunction<PEAK_NODE_DISPLAY_NOTATION>(
        [&](PEAK_NODE_DISPLAY_NOTATION* displayNotation) {
            return PEAK_C_ABI_PREFIX PEAK_FloatNode_GetDisplayNotation(m_backendHandle, displayNotation);
        }));
}
 
inline int64_t FloatNode::DisplayPrecision() const
{
    return QueryNumericFromCInterfaceFunction<int64_t>([&](int64_t* displayPrecision) {
        return PEAK_C_ABI_PREFIX PEAK_FloatNode_GetDisplayPrecision(m_backendHandle, displayPrecision);
    });
}
 
inline bool FloatNode::HasConstantIncrement() const
{
    return QueryNumericFromCInterfaceFunction<PEAK_BOOL8>([&](PEAK_BOOL8* hasConstantIncrement) {
        return PEAK_C_ABI_PREFIX PEAK_FloatNode_GetHasConstantIncrement(m_backendHandle, hasConstantIncrement);
    }) > 0;
}
 
inline double FloatNode::Value(NodeCacheUsePolicy cacheUsePolicy /* = NodeCacheUsePolicy::UseCache */) const
{
    return QueryNumericFromCInterfaceFunction<double>([&](double* value) {
        return PEAK_C_ABI_PREFIX PEAK_FloatNode_GetValue(
            m_backendHandle, static_cast<PEAK_NODE_CACHE_USE_POLICY>(cacheUsePolicy), value);
    });
}
 
inline void FloatNode::SetValue(double value)
{
    CallAndCheckCInterfaceFunction(
        [&] { return PEAK_C_ABI_PREFIX PEAK_FloatNode_SetValue(m_backendHandle, value); });
}
 
} /* namespace nodes */
} /* namespace core */
} /* namespace peak */